{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-02-07T16:46:08.704311Z",
     "start_time": "2025-02-07T16:46:02.278238Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1 特征中含有字符串的时候（当成类别），如何做特征抽取"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def dictvec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化\n",
    "    # sparse改为True,输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    #矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    #Vectorizer中文含义是矢量器的含义\n",
    "    dict1 = DictVectorizer(sparse=True)  # 把sparse改为True看看\n",
    "\n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 调用fit_transform\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                                {'city': '上海', 'temperature': 60},\n",
    "                                {'city': '深圳', 'temperature': 30}])\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 字典中的一些类别数据，分别进行转换成特征\n",
    "    print(dict1.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(dict1.inverse_transform(data))  #去看每个特征代表的含义，逆转回去\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "dictvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:14.553238Z",
     "start_time": "2025-02-07T16:01:14.524721Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Compressed Sparse Row sparse matrix of dtype 'float64'\n",
      "\twith 6 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t1.0\n",
      "  (0, 3)\t100.0\n",
      "  (1, 0)\t1.0\n",
      "  (1, 3)\t60.0\n",
      "  (2, 2)\t1.0\n",
      "  (2, 3)\t30.0\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': np.float64(1.0), 'temperature': np.float64(100.0)}, {'city=上海': np.float64(1.0), 'temperature': np.float64(60.0)}, {'city=深圳': np.float64(1.0), 'temperature': np.float64(30.0)}]\n"
     ]
    }
   ],
   "execution_count": 44
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 一段英文文本如何变为数值类型"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(res)\n",
    "    print('-' * 50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-' * 50)\n",
    "    print(res.toarray())  #稀疏矩阵转换为数组\n",
    "    print('-' * 50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:14.586015Z",
     "start_time": "2025-02-07T16:01:14.571114Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 45
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 一段汉字文本如何数值化，对于汉字不能用空格来分割"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(data)  #稀疏存储，只记录非零位置\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:14.656618Z",
     "start_time": "2025-02-07T16:01:14.642899Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '我喜欢']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 46
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.3 掌握如何对中文进行分词"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\n",
    "        \"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "    return c1, c2, c3\n",
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()  #jieba分词好的中文文本\n",
    "    print('-' * 50)\n",
    "    print(c1)  #把分词好的文本打印出来\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-' * 50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())  #把处理好后的特征名称打印出来\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "# cutword()\n",
    "hanzivec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:14.741239Z",
     "start_time": "2025-02-07T16:01:14.723895Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 47
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1.4 tf-idf"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "\n",
    "# smooth_idf布尔值，默认 = True\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(type(data))\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:14.801175Z",
     "start_time": "2025-02-07T16:01:14.784128Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "execution_count": 48
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 特征处理，不同的特征拉到到同一个量纲"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    out = mm.transform([[1, 2, 3, 4], [6, 5, 8, 7]])\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:14.913322Z",
     "start_time": "2025-02-07T16:01:14.897435Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 49
  },
  {
   "cell_type": "code",
   "source": "(1 - 60) / 30",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:15.028808Z",
     "start_time": "2025-02-07T16:01:15.016087Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.9666666666666666"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 50
  },
  {
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.],\n",
    "                              [2., 4., 2.],\n",
    "                              [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)  #方差\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data = stand()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:15.089088Z",
     "start_time": "2025-02-07T16:01:15.076826Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 51
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:15.150986Z",
     "start_time": "2025-02-07T16:01:15.140633Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#如何求方差\n",
    "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 52
  },
  {
   "cell_type": "code",
   "source": [
    "type(data)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:15.206252Z",
     "start_time": "2025-02-07T16:01:15.197334Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 53
  },
  {
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform([[-1.06904497, -1.35873244, 0.98058068],\n",
    "                            [-0.26726124, 0.33968311, 0.39223227],\n",
    "                            [1.33630621, 1.01904933, -1.37281295]])\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:15.278428Z",
     "start_time": "2025-02-07T16:01:15.268936Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0.]\n",
      "[1.         1.         1.00000001]\n"
     ]
    }
   ],
   "execution_count": 54
  },
  {
   "cell_type": "code",
   "source": "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:15.317051Z",
     "start_time": "2025-02-07T16:01:15.307214Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 55
  },
  {
   "cell_type": "code",
   "source": "(1 - 2.333) / np.sqrt(1.55555)",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:15.370200Z",
     "start_time": "2025-02-07T16:01:15.361794Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(-1.068779614944516)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 56
  },
  {
   "cell_type": "markdown",
   "source": [
    "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 3 缺失值处理\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:None\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    #mean, median, most_frequent(众数), constant\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:15.401112Z",
     "start_time": "2025-02-07T16:01:15.388584Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 57
  },
  {
   "cell_type": "code",
   "source": "11 / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:15.494882Z",
     "start_time": "2025-02-07T16:01:15.486057Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.6666666666666665"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 58
  },
  {
   "cell_type": "code",
   "source": "np.nan + 10",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:15.566702Z",
     "start_time": "2025-02-07T16:01:15.559283Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 59
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "# 降维就是特征数变少\n",
    "# 降维可以提高模型训练速度（特征变少）"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:15.646866Z",
     "start_time": "2025-02-07T16:01:15.634962Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "--------------------------------------------------\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "execution_count": 60
  },
  {
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5],\n",
    "                               [6, 3, 0, 8],\n",
    "                               [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0).sum())  #最初数据每一列的方差，求和\n",
    "    print('-' * 50)\n",
    "    pca = PCA(n_components=0.99)\n",
    "\n",
    "    data = pca.fit_transform(original_value)\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差和\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-' * 50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:15.701519Z",
     "start_time": "2025-02-07T16:01:15.685342Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-1.28620952e-15  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 61
  },
  {
   "cell_type": "code",
   "source": "22 / 29.333333333333336",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:15.797804Z",
     "start_time": "2025-02-07T16:01:15.787812Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7499999999999999"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 62
  },
  {
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "x = np.random.rand(10000)  #每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t, x, 'g.', label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-07T16:01:16.082801Z",
     "start_time": "2025-02-07T16:01:15.820949Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQe8VMX1xwdQEHtBERURwYJdETtGUTSi2Hs3IgKaWIgVSxJrbKiRouJfY8EaG4pR7GJDsWHBgoAFROwIigX+n+88zjI7e2bu3N2Fp3n70/d5vC33zp1y5swpv9No9uzZs00NNdRQQw011FBDPaFxfd24hhpqqKGGGmqoAdSUkRpqqKGGGmqooV5RU0ZqqKGGGmqooYZ6RU0ZqaGGGmqooYYa6hU1ZaSGGmqooYYaaqhX1JSRGmqooYYaaqihXlFTRmqooYYaaqihhnpFTRmpoYYaaqihhhrqFQuY3wFmzZplJk2aZBZbbDHTqFGj+m5ODTXUUEMNNdSQAHhVp02bZlZYYQXTuHHj37cygiLSunXr+m5GDTXUUEMNNdRQBj7++GOz0kor/b6VESwi8jCLL7541a77888/m0ceecTssMMOZsEFF6zadWsoRq2f5x9qfT1/UOvn+YNaP//++/m7776zxgTZx3/Xyoi4ZlBEqq2MLLzwwvaatYk+71Dr5/mHWl/PH9T6ef6g1s//O/2cFWJRC2CtoYYaaqihhhrqFTVlpIYaaqihhhpqqFfUlJEaaqihhhpqqKFe8buIGUnBr7/+av1eecDnF1hgAfPjjz/a79cwb1Dr5+oDv26TJk3quxk11FBDDVXB/4Qy8v3335tPPvnE5jPnAZ9ffvnlbZZOjb9k3qHWz9UH/Uia3KKLLlrfTamhhhpqqBi/e2WEkzaKCJHAyy67bK7NDjI1FBkEeoyMpYbKUOvn6it3U6dOtfN+tdVWq1lIaqihht89FvhfcAEgnFFEmjdvnnuT/Omnn8xCCy1U2yTnIWr9XH0w3ydMmGDnf00ZqaGGGn7v+J/ZGWrm/xoaEmrzvYYaavhfwv+MMlJDDTXUUEMNNTQQZeTpp5823bt3t0VvOJ3de++9md958sknzUYbbWSaNWtm2rdvb2644YZy21tDDTXUUEMNNTR0ZWT69Olm/fXXNwMGDEj6/Pjx483OO+9stt12W/Paa6+Z448/3vTo0cM8/PDD5bS3BgWrrLKKufzyywt/f/bZZ6Zr165mkUUWMUsuuaT5PQFFdV60mfgKlGfmoCjI/P3NN9/M83tVGz/9+pP5/qfvzS+zfpkn1/894pPvPjFPjH/C/q6hhhoaQADrTjvtZH9SMXjwYNO2bVtz6aWX2r87dOhgRo4cafr372923HFH878CNogff/nRLLTAQqZpk6aZn99mm23MBhtsUKREyGaMwpZnk3zppZes4iGgbydPnmw3wyWWWCJXG2WjA4s2XVT9XN5nBUsttVTh32Q+YVnbcsstzZ///GfTsWPHwnv77bef6datW9I13b7y2+T/TaEm+qRFixaZ1w09n/b64Ycfbu/vWgjlXosvtbj5buZ3RZ93rwFibdbuN3X6VDPx24nG/GLMF999YW564ibzly3/YlZavK4aJpvxmGljzHrfrWfaLtPWzA9wz/e/fN+stsxqhXbMy+/5uO6V60zPB3qaWbNnmcaNGptrdrnGHLnRkfPl3nkRuy/vPffRc+bLH740yyy8jNmi9RZFn6lWm1/69CXzzEfPmM4rdzadVuxkqol50a9f/PSFeXLCk6ZDyw7zdazmF6TPFm26qBn/9XhjGpnksa+vefy7zKZ5/vnnzfbbb1/0GkoIm0gIM2fOtD9u1T9A5oBPbCbZNGRs8JMHwksi37cD+9X7ZrWlSwf251k/m5m/zDTNFmhW10bn359P/9xMmT6l8Nk2S7QxyzRfJnhfrvXrrF/tj7SZ11ACvp/5vZltZpvPpn1mJ+fCCy6c+RxserSHnwUbL2g++OAD6xZr166dfZ97IODsJua0cfFmixeeg++5n/n5p5/Ngk0XNCsutqJpuUjLwvd4zk+nfVr4238/1s/XXXed+eMf/2jJz9577z1z7bXXmk033dQMGTLEHHroobYPfm70s1li6SWSxlI+U9igpT+aLm6++6luzoBWzVuZVku0Msstt1zhe/Jd+feMn2fUWRtm/2I++/6zoudbZMFFzPSfp5c8N68zhjJ/BFhFmizWxLz95dtF/Q3cdrpgvtD/gqUWWsp8/ePXRfdbuvnSJd+/4607zCWjLjGDuw02X/34lTn98dPt/Dl7wNlm0E6DTNdVu5oPvvrAtF+6fW5hxXrI+u6lL1xq+j3ez8wydYoA9zxigyOC13v+k+ftv8d8PsZc9NxF9nuNTCPTY4MeZptVtjGbr7R5boVGFBHA76MfONp0adMleJ3rX7ve9H6od0F5kTanPK9A5FAK0aJcd/Rno02/J/oV7nv+NuebjVptZBZpuoi56527zOUvXm7HTkC/XLDtBfYz/ndj/Ry6P8919lNnm5vG3FR475B1DzHXdb8u+p3U8Qj1a+x6sfvw3hUvXmGufPtKM/vt2bmfO4Rynm1eXcvtMx8XbnuhOXHzE0v6VeZNJXPCf4axU8dapS8vcWgKUq85z5URXAYtWxZvVvyNgvHDDz+o6bgXXHCB+fvf/17yOiWOOVW7gNkTQi14LEgfLQfTpk0zN715kzn+8eMLA3t5l8vNIescYt//7pfvzOc/fZ58PbthzDR2g/ch15rxywzzxYwvzMQvJ5omjZoUrj91xlTbhk+m1ZmbzzvhPPPT9z+ZzTbbzLrGeMY999zT9hEsnFxvsw03M/v32N8ceNSBZo/N9jCffFz33Ztuusnss/8+5sqrrjQvf/iyufiMi81LI1+y6bWbb7O5+eu5fzXLLFunNN3Y/0bz3+H/Nfsesa+5/srrzeRPJptRn4wyKyy+gjn34nPN0yOeNk8/87RZfsXlzZmXnmmWWmYpc+5J55q3X3vbrLX2WmbINUOsBSwGYoYYP354Hn6aNm1q/vKXv5iOW3U0MxeeaYbdPsxc9rfLzBsfvGGaNW5m3n3rXXNWv7OslYdNftVVV7WWH9yFRx5Zd/pdbtE6JeOoE48yPfv2NNtsuI3Zdf9dzcfjPzZPPfyU2WanbczfT/+72XjDjW3M07rrrmtmzJhhvzNixAhz1t/PMhM+nGBWX2t10++Sfqb9mu3te9dceo158r9PmqEjhhaeYei1Q81tQ24z9794v33/5ptutq9Leu2wYcNMq5Va2Xvd/PDNZo111rCv3/3fu82V515p3n/7fbP4koubnffZ2fQ+ubedv2Dvnfc2q3VYzTRt1tTcd+t9ZoEFFzB7HbKXfR6AIjRtxjS1X9nAjh5+dNFrdlMefrTd0GSD223Z3Uz3ZbubFk2zrUMjvhxhBnw81xV7TOtjTNdluhb+RnDdNOkm89Q3TxXds/fw3qbJhCYl9/Cv57f/2teutT+0t0/rPkX3imHk1yNLBPmvs381A4cNNGsusqaZPHOyadWsVaE9tLvX270KfcJ3ew3vZe5+4W7zyFeP2NelDRsutmHJ90v6acSIaPt47oEfDyxSMuS+pz5xavS7fEf7TKyffdwz5R5z4+QbS+4vQDFZ98d1zeqLrK62WRsP+nDs9LH23/QxbdD6Vdr46rRX1evF7qPNlzzPHYJ2T3+ceZascU/ppyz4feaDsX/5rZfNfz7/T1G/huYE8/jb97+1Y1nuMzBWeZ4hBSJrf5c8I6eddpo58cQTC3+juGD63mGHHWyJYxecsmH2hFALHos84ESLIvLt7G8Ligjg9wmPn2B2W2c303LRluaDzz/I/QzNFm5mLRsuOPn71/ry57mnYQ0/z/7ZurV4/scff9xaPQ444ADTqVMnc/iRh5dc7/8e/D9zyUmXmOaLNDe9zuxl++SjHz4yfY/oaxZeZGFz9X+uNr/+8qu5qN9F5vTep5ur77rafu/HWT+aTyZ8Yh4f/ri5aMhFRXwgV156pbn4kotNzzN6mqvOv8qceeyZZoWVVzCHH3u4VU7OOfEcc+ppp5qHhj8UtYygePrjd0LfE8xtt91mHnj0AdN1164l/dKjZw+z0YYbmRevftFu+CglxJRsvvnmVik5++yzze1P3W4/y/MJbr76ZtPj+B5WQQFNm9e5OXBn0QZRas/+29nmL2f/xSplAy4cYPoe3tf855n/WGUgCwf3OtiMf3+8mf79dHPWZWeZZRde1qy+0urmg4nFY/L55M/N8Yccb3bZdxfz9yv+biZ8MMGcd9J5VjkTZQM8cOcD5qCeB5nrh11vxoweY/5+wt/N+p3WN5tuval9/7tf51p7UuEKuvum3mfun3q/PW1z4oqdlPa4ao+i19gY+u7W157+OKn5yo8AS0ebDduYP7T5Q/R6sfYO/mRw4V4x0I5LX6tz//q4dOKlheu5p8ZTHzu1RPjz98NfPVz0NwIa5Td06uS0hyKy1mZrmQnfTQie7PccsGdws6kEWj/7uOz5y8y/X/t35rUat2lsum3STW2zPx70OZuevM8GhlWu7ZJtrfXCb+PCayxsBt07qOh6gz4eZA7c7kAz6N/6660WbWXbUO5zh6A9mz/OB61zkLnlnVvs32KZ0tZKVj+lWFOaz2he0mc+7vr8LpMKq7y+f6o5aN25z6DNXbk/Fjl/DFKfIQ/Es1HvyghWiylT5rowAH+zIYRIyhDS/PjAEsCPz8DKZGLzzEuoJab1D77+QD1dvfDJC2b7dsUuplQstGApwdfMn+e6nvKAkzRWETbjtdZaywYEP/HEE+aAww8o+SwWiyYLNjG/NPnFtFiuTiN+8ekXzbix48y9z99rlQfwtyv+Zvbbdj/z1mtvmbU3WLsgYNksuYaLXfbbxWzXfTsz+fvJ5tA+h5o/7fonc+TxR1rrCsAqg0IS6n/XheF+BvfKz0vXmfCwxGiY8ukUs3avtU37NdrbuIm27dvaOIrGCzS2SgljL8/potOWnayyIGj2Q918knki7Tju5ONMp63r/OZ/u/xvZueNdzZPPPREkWIUAspPs4WaWZcWbWAxv/vNu+bHn38s+txd/77LtFyhpTn5vJNte1dpv4qZ+tlUq9j1OKFHoS1YRkR5WnnVlc0dN9xhRo0cVVBGqgE5bY//brw5Y+szVP/z2C/GqhvoRc9fZPpt3S+oiACE35rLrVm0Ttms82zIrL2J0yYWYl4klgJfOpse7jQUfUzXoeu6r8uJesMVNjT9X+yf1Aa+L0o03+/zUB/TbY1uRf2F1WHPwXsWXFR+rArPrZnfqwGsqX4/u6DPTnvitKRrbb3K1oXraG2W8eAzriIC+Dd98/yRzxdZ4QrtbNKk5Hr01xUvXaG+vtUNW5mjNjoq2m+vff6a2b799kWxFsyJrLgJ7dn8cXZdWLJWmizQxOy/zv6F2Axw/evXB/spFqvlxjfRX1qfVQL60H0Gf+6699eQ8gx5EZqj810Z4QQ7fPjwotc4UfD6bwXEiCBM3AHibzTHD7/+sKxrTvl+irWqAAlClKDFvFizw5pFLJutWrUyY8aMSb4ep3c2Q1FEwKqrr2oWW2IxM+H9CQVlpNWKrUoUEdkkUUTA0ssubX+3W7MuHsW+1mJpa6FCA0bJTA2UxZ0lgiBE4nVgzwOtO+ip+58yW22zlem4fUez0ip1AmfaTN1tATqs16Hwb2JacAlq2HTzTe0CBksstYRp066NtVxUgq9++Kro7/EfjDfrdly36BmxeMyYPsNaTWRc2neocw8JUHC+/mJu3Eg1cfXoq821r1xb2ECzhBS4ZvQ1Zr2W60Wv+8/t/1myISDA8whdNlosDYB2HTXsqJLv5hXijPElz19StuBHSHOalGezVofJc60OEquyY/u6oHzZJH25Ug3QP1fvcrVtSyiAkddSnvWw9Q8rCmJ9edLLJZ+hr4mPIj5JuyZ9M3rSaPX69797vzpWd711l9o3fO6aV66Jju+pj9a5KU559JQSmR0LXqaPyhmPk0ecXHIvDdJPqfFN4hphPH+dPe8KiMrcBVlr3F17v/nUXmIzMJVL2iKpu/z7o48+KrhYCEYU9OrVy3z44Yfm5JNPNmPHjjUDBw40d9xxhznhhBPMbwUs4iv+eIWdqIDfp291ekGZKAcEer4x5Q37896X79nfKCiYIMEiiy5ivp9Wl7XiYtp308yiixW7d5o3K7YgsalhEWLD9wU/gZILNI7rmKsutWohoNLFQgvryo3rspANVWIdwPKLLl+wgGDtcJ+ZvwUzf51pg0On/zTdth3Ixr9C6xXUe+PGuP3x203XP3Y1Ix4bYfbddl9ruQDE3ITAs0jMDmPBaV99tkBf0UdLNl8SiVEEXFzzCm6fAms+dqxKjJk/bgizciEbKNkVWULKft7MKgru9XHwugebv27x15LXH/4gPY2f53E3Wk0RAeUoFbIBlgNXSIesDgj90x49zbS5vI3pcmMXs9l1m5lD1jvEfleucdH2F5knDnvCXNz14sLrKaDd8t0Jx08oKJByL37zt7/x+uC+o3qMMv137G9/37D7DYVnuuPNO+ymq/X1pkM2NX0f6au2zcZLDO+jjsktY25RX2cu4f6Izd/Gge2JftaUA/7uOaxnML2bOYWyIv2eunZof4oCw+cYc3ccXKAgasrXtqtsa1KxfdvtC+PKc7BPZT2HzF3t/j66rBIO/J7XyG0Zefnlly1niEBiOw477DCbaklKoygmgKDGBx980CofV1xxha00SvbEby2tt2fHntYEzERmMDRFhA1K4kAwC+a1mkjGDdozJ/AXn3qx5DPvjnnXmugF3O/Hn4rN/j/8/IP5/ufv7YYPmjRuYpZbZDl7asUSQWxKEzNX0LVdra2ZMmmK+ezTz+wpnGuOenWUmfbtNNN29XzmuJWXWLnQF2sss4bNxPm++fcFa8dHM+aOPcD6QdaOBGGKoCBbBNx67a1mkcUWMZt03sT+vewiy5YIUfqKnx0O3sH069PPBrluu9O2Ntvnl1/DXBv0Q8lrv9a99s0PdanTDz7+YMEl890335mPPvzIdFqvk+2jJZde0nw59UtrvREljIBawBz59sdvbRtQDEMgjgTXErE47nVef+l1q5Au16ou+DYGmXdiZVpioSXMtOnTTLNpzcw5255jDn/w8LJPVnxv5EelQaAask5wpCPK+vFPg6nKA4LVtS5kfU9OuimWEjbAv27+V9P/+f65++vg9Q4uKEh9H+4bvNfNY26ee7/Zs8zNb9xsXRhkY7lxJWQOYfq3vnusDm/fEW/XbGMOWPeAohRuLYuIvuMzKIBuFXP6B6uVKIuuNSTFKhbr23IUQ+YSFsuYm+28bc8zpz9xesl7PEuorYzxuU+fawbvMlh9HyWOPqLfH/3wUXPeM+eZakLGAVnsuo4YLw5mmmXm0fGPJl/f/ewF211g58QFIy9IsqKBLMvQ4xMeL1nDv1llBH4Md5L70NhV+c6rr75qfstA0G+y4iZRawgnbdkQSOksFwimvQ7dy9x5w53mkjMvMbsdsJvd1J597Fnz8H0Pm8tuuMxuYq0Wa2VdHT+aucoIGz7cFS5oCyd84aZAWVm0+VzrChs9bpWz/nyWufjSi81LE18yPXv1NBttvpFZa/21crVdUo2bL9jcLNZssaL3xNrhg00boPx88fkXNsbixQ9fNA/e+qB55MFHbPwKLiNO/W82fdMKmw4tOphXP37VZqBst/N2NmAWl8bbr79tunTrYq9H1grBo6OeGWVWX3t1s1DzhexPDGQr4UYRxXDI5UOsewb3078v+7dZbtnlzE7dd7JWndU6rma+/vJrc+PAG20bnnvyOfP8E89bJYIFS7rtCiutYF548gVr4UF58a1a3K9Pnz7m1iG32mwmspUmjptoM3FwQbkxNEsutKSdf1jQBCghpPS6YJxxITLmW7XZygzdc2hdLMqSq5hrR19rrn31WpMKhNVWK2+VKaR4H+GnnZwFnI6PfehYe/pE4KNMSHZYKthMnv/4ebPP2vsU/POxtrPRT/hmgtn/P/uXbL4SmOh+/rhNj7M/pIxe8twlye1CqVhnuXWsyT5v/AvrHeXDBwJfhD5rfdqP06yLImRJoF9aLNzC9ot2yvXN8f512Lh8+ErNvITMMcYhay7x2XbLzHUF+wdHXIyhNuOCRPHTrHRA+ny7G7crea8aMRyMAxYSCSDFOnbTGzdVPU7klEdPMW2WbBO91qlbnVpwW4llCGUppPT67sj5id9kNk19gE2cUz4CHeGmQXhFJN6hEqzUZiWb2TLon4PMMfsfY4NHV2m3irnw6gvNFttuYYU4AspHaMNHAZFYDR8I5aF3DjV/O+VvZrcdd7Mb4KZ/2NSm9uYBygIuFoDWz/3cmBAbw6LMcSFR+8eJ/7C/CfpcdvllbdzE8CeHm807bW771r0Wi4I4mW+//tacfdzZ5qsvvrKbPRYRyUDh+6S/khXE5yS1N4avf/i6yKJ17GnHmkvPvtSmAa+3/nrm7nvvNpN/mFywKJ1y/inm+n9db667/DqrBB189MHmnlvuKVh6dj9odzP6+dHmsG6H2RiQwXcONq1aF49b65Vam8tvutwqVgd2PdAGJO96wK7mT8f9qehzP836yZ4WOSnDroriFyKdo09RSnf+985m/PfjC/7yATsNMKt9v5qNqpdYGDF533fAfeaqUVeZh8c9XHTi55R84XYXmpMfPbnoPnzn3G3PNT/++qPZZfVdzPhvxmdbH2bPsq4VUQRCwjem/KBY8GwI0b077G05OEInPtpOuzTzd9/N+xasDX6cBTEfeSCugbybCM/OxhgjpwrFxfjXoV9kg2O8/D6MmeO5NgoYbhoXz3383PxRRExj88KRLxQsRFkuA6w4WNr8Z6QfjtzwSNNphU6mx7Aewe+jNGJ5Cm2qofvv0G4HazGpNIbDtVj9+/W5sUXlKCGNAsoLr30146voWsJq0mvjXoVn5pCAmw/FFjc3hwdtDtUHGs2OmTl+IyAwEibRb7/9Vk3tJW4Fd1De1F788Vz75wV/zlQu2IhxIdj2zPyu4CJxwUbikp9VCtwgvvWBjYhTewjEpEiwqQtx4aRcw78ebhZRFnyCMbdfADEFeSm53bYJQm3EYkLsCZsxZHMxNGvSzH42TztQ5rSxrQS0+Z0v3in7+24fFzGwfvqF6fVsLzNx+sSCIHn/mPfNGyPfMFNWmGIzSGymh2lsruleZ60gtsAXPggnBBWxByFByO+eG/U0V79SlwqeB+LTdgUqvu6u7bragMlTRpxSpDi5Vg85YbogrfPmPW8uZAdoGznPPPGEiWbytMlm6Jih9n1SHlFeoI3XnjXrGcrdSC7qelEhxsEPsmSt+GOScn/658LtL7TBnK6yxRiTebTff/YruYaMtWzQ9F1sQ68maP+13a/NfG7Gjec6acuT7N/XvHRNYR4XPtOosdlzzT1VJdXFHXvfYS1sGrj/yv1XVgOjX+zxYsHapo0LbSTjZ7tVt7OHV1xslz53aVWsHY1N45K1EMPxmx5vD67E5oSAhQjlW+YffXf32LvnHhYktdk0NoO6DTI9O8UPdNXcv100+Kq9xBXEFBFM8WwmbMZskCCUxVJNRcS1xLhg09aCTwWaIsLn3c0+6xr+9UQR0SxC/C39wkZZTm0QsZy40NrI3zClYtnIUkSIocmjiCCguWe5GU8h0GZcKqn9rUH6OMsiZ9PRP31h7guNin/HTPuhgEeXgyCkiGQFhWpC+vyR51tFBEF569635oplgcocZAW4nvH4GWaTIZtYZlOsAvz78HsPDz5r3mcAYvmJfc8NtpSYAlknKUGF2v3pn41X2NgqFxLUCtjgNUXEd+OIeyaEQjC/aWwOXOfAzPaltN99bi2mhXgeFEhRRAD8GBeudmFRMCv9laWIpKx3lGutnSgiKDEojf7YShsHdx9sP4Nyi9svlA2YF9ftdl3J3ESJ7Ne5n/p55nZMEaH9KEru/KPv3Iwe/h+6+1BzzVrXVMxuWwlqysjsOFUtpnhOtW52SJ7NvFzI5ujHiuAmQTlAQWq9eOuyr89Jm8DIFEAZH3MR8X41XFdaG7FWYCHiN4GbqffIUlZ8SIAZfe6bdonf4ScPVlhsBdu/tNl9lnLHjD4O9b+Lg+892PJfuBTTsgFiItcEnQRWYhqX91MzDTD7uxkKbBr+d3lN28zZpOl3McdrsSxaO3geNlVcDLEASNc8LuA1rCXaRpMHPNPuy+5uxh07zp6kz9r6LHP+tueXPIc96UZiO8pRjPxxk3gUFLOsuB8xwceUIK6NSwUl559d/2lufbNUWSwH8txaUDNjcdxmx6nEce9MfyeXtUCut3nrOH1El1Xj1jEJpHZx6fOX2vnjFmXMUih3bLdjdH24OPL+I4sysPg88TXndjnXrrU8c0WsaSmB3cinclltq4UGr4ws2CiNkMU/pVa6uQgkq8SHm6/upsuKYsTvVLOga71w4TPEZllo3DRd/33NupEKvx2ieElMCq4qfqdsxpWAfvr0u7kZP+Km4v6YQvNg0rRJ1oLDuEk6LM+wVHN9vLNAH6ekgiIUof/WNsDdbtutxEUjcRSY7OUEjxA7YJ3SYEcNXEP80GxenBoxx7vClCC6UFslWM5VaKRdxExpp9fCplqmVfzZj59VN5o86aU373GzOXzFw82ID0dYV9I/nv6HOePJM0pSeXE5aAqKrG//2Xnv6I2OLvmO8FFoGRIgppgJTtvqtMJ3QkqQG4tDG8uJkwlBnlvbvNkQRUETMCfbD2hvrp90fe57nd75dHufmKUWJbhEcW7UuKDE4O7S2HpJc3bTqWMKJdcfsusQuz5wG2EFxG0XUkhmzcnAYs3YWBAzy7IGcx+siBOPn2gu2yEe78S1mUOp1hobLLyUHiw8P9HglZGvfi4mqEqBbLxsLqkbeghuMTQX4hYi8yNkDciTgiXWDRcpFh4sAnwOi4zW1iWaLZFcuVeD3F+UjxhPSciF0rRx+ffPcnPxd1YKdxYfDePkKiRZhQVDSHU7WQp0ZWkXEUSZxjYmAx++zzPC929787Yky8GJj5xohTJmd07ozEeuKZswwjSUeugGy/EdzeWguYbEvL/FyqWbSQq2bL1l0uYNpJCf3+7NVtzM1v/wLVCSyivPgcvBVTbkmmxoFz97ccmzv9DjBbPfOvtZK5WrfKDguf2DMuWezlP0BcaBe/I94CtBuCBcDhPamDe4levsuOqOukXLzLKusitfvDJooSsny8d1lXF/gp55VhQG4kKkn91rSx+4ijO/6ZOCTA1MLbdODBZHELO0sTb4IQZlv7v2swoeMSch/Dr7V9t+zbVH20JxMIX+aNTIHqBSx465Bqj2XY6bvVr4n8mmKScOl/iDab+GWTxD+HLGlzY40k0RrQQEiLrpumzQpMOmuCRI6yU+IjOYU4k/AVh4cCWEeFOwCJDV4acTC76d+a1VVMpRynA1MQaxYFr6gPaxiYsLxV8wZKHUJ1AuSPuOLWTeI0WXZ1iwST5rnCiTRYyz1tVb958f3GhdCGvuboPUQmBjwG0TCgC1nBxbzOXkQFCTecNm62caCNmUcFzwrG6cRGjTP2HzE4qUaUl1zdqIuB6naJQfTpmSbusG40l7fVeNMI7aUu05IBwrYjYHj3z5iGqB8lN52dyxorrBuLSX7CXaSz8LN4g8t2TM0FaXn8Sn9JbPITOygmz5vGRMSSAtyodwndAnKGnwLeXhhhFApIaix3PGvnvvu/fa39Je19KDYkxMUPMFmidtpjZLp8cL1orGcyDHXAug38/+fIdITvrAry8klpPYs4jribnPPfx9iO+yNtBTXOViyCtDglkwjSOuPWlfrF18l4DVrHR9riFKERYoPku17xiL7bzE714ZEZp0qtmGat2EEHIt+OXbtQ2Yn2qBjZ6FwIbDps5mlZrtogWsZgWwAp+ynY2S17QNNUspwmUk7KB54kY46ad8nn6R9gvPSRawViy90NIVZbGkwCWhygKKK23SPst1Fmu6WLC9CJYiV9EsY9N/p/08zey91t7mzrfvLLy16RKbFgR+CGwAzP/YpoOS5QtqfNd3vnWntYiU1BuZkzqami6671r7qq9n+eDlFC2uJVFEOOHBpeG394F3H7CWqZ1X37lA9tV2qXSyP66P0IYDhHZxTz8N2m+bC8abDVZ7Jq5FCirwScxOe+y0ouwXuZb/OWmLm0adophw2ub6474al5lanAICkomVSj2RSztR7tj8CC52lcdUIjuUP1HmQs9BP5OF5WcPuYqKBtLDL3thTibKnNgn//o8N0pIjIjNb5K1uM3WLSl7dpib7eK7uLDoIAfyEvz5WTNdV+1qRowfYed00fc88rz5id+9MgKFNhVYp06dagvy5CmWt+DsBW2KpI+lFljKLLJwHbHV/IJbfXeZ5suo7coLrrPMwsvYf3/x3RcF6wK56ZO+n1T43AqL1lGxu6/lxcQvJ5rVl1ndrL7E6pblFItHltXI1otJeM7Zv8w2P86uixf55adfkr6ziFnENJnVxKyw0AoVPVcWPvnqE/ND87TnmPLNFMN/Kn4x5vMfPlevw/j88KNzj9nG/Pjtj+alqS/ZAlh+gOEL376gCiuXdAqrwa637honTHr0VLtRCi8EEDOxr4wABB8KDJaKFLCJlFNDBIsK8F1LbN5YJNzTKe3t1amOZ8EF3CSpQJCLIiL30oCQP2Gz4jIXWeymEjejbWYaAdUVL5QWmPPdc7fvfbv9Ny6BGLg+fBPVUEQAWR385EmDlnHrsGyHEiuWfZ458yCU8mpriMFg++YdUcWaa1w48kL1PVLLfU4Sv6AdGzsBtreOubVEEWWdhOKibBtxmTqWEff5NNz9zt3mqI5H2VpQBZfQHNdewQKY0ccuwZ8o50CsYFrKfH0Tn/3ulRG0PQrHwTUycWK+bA4EAPVhfpw1NzCSNEw2UU6dbOD1gS/MF1W7DgGTEH0JqLciVOjVvl+Tb5sUxXU0m9XM9iMncCFLK8IixnwxPX5vlKlPp39q/811cJGlAA4O3F/4TpuZZpYUzi9gVy1Uo/9obwjNFq9zscl8RAh98cMXZvC7g83UH6cGNyVXeAtvBwqACKOsDQOhhLXD5SgQdtXQ51MDHmPkSghBjYQN8FwI2FCasst8GTI3Z/FrIOj5vrij7Fk4wQ3M5yjGx0la+ikr7sHNcCkp1mkaW/erxArwm2yOlMwIrpllpmcMYtkWPmPq5zM+LzppZ22G4tbKyoThcxTh03D6lqebZpObmS6du5jO/+5c8jx7ddgrurG6CLkt3eBZKXDoK7r9X+hvlRHSqbX2x+KicEEBYT7N6pNZZpZlkY2l2fvYYqUtzIufvlhC8CcQwj2UdawrWf0VK/g3r/C7V0ZA06ZNzWqrrWZdNXkA6+n4p8ebpddc2rwx9Q2zUauNzLot1y28//pbr5uznjgrKa0sZMIrF6Q1wrMg2HD5Dc1rn72W+/qagMubJpcCFsBjhz1WKJrnFic784kzS9rN52/b+zbT+5HiMvAIuYE7DzQTv5loOq7QsTAe1sz+753zB9Q1amz+sc0/zN5r722LmN0zto49VYNGIZ6KP234J3PDqzcUAh7z1GIBUQvFlqfavnjioyfM7W/dbgXOZz98Zn6ZrZtjGOPzupxn+j3er0B6JhkSIEUYyXVEEXFNuEP3Ghp8lqTrNmqcWXVWE/rgxC1OjNbZ8Nvqm5uJScASkJWJseKiK5pjHjom13rzAxvpp6z+ECXHp+qWOYR1g3/jLmD8strjpvxyvZjVgyDjUFyEq7zK9RirTq062TUCeyf0/6F+uHWvOmvdmM/HmHOePsdkAbp0DRwgWvHfoq2K+keytC589sKKGWS5Fq4W6OHFEqLxurh8PCUyVWkDMTS4UGX+SU0cNnqxclQLL376oloDyY8vEiU5S0aFrJbzEv8TygjAPZOXgZV4k19++cVsvPLGZvN2pTnpB3c82Gyz2jZFp0MfrqDIMoumgsl969hbi+5HPZNqQQt41MyIea5HVPoqLVYpeh3hddiDhwVZFu949w4zYXop9f7Od+xcMNHK6Xb85PGW9rwcUEiOcey/S39z4IYHmgfff9AKSL9dR3c8Wj2RZAHBvXDzhc3EGRMrFowaUNhSQZ/1Xql3yUnKtQqlllJHgfNPrLJRat9nE3ezAGK04KwXTVCKJSMk9LGKAIQtwajXvxZO+/TNzVm06zwXJ+2sZ/AVyNDmlWJOl2BcyUJio8B14rJ/isUllK0hVgj/RMz1iJ3qfmt39XsofHx285U2N8998lzRe67yCvyxQkEOgXYQC6ZV1s2LgaMH2t8SWOnGMKHEQp5XKU7rfFpmwLWv5KUoRViFfYVbApuZZ5USt2UFToeKKd67f3Y8WX1Qwjf41F4Nkvol5lGC8giOCwkDFi0R6OWWJ/dBoN282NRCQDFggYU4FbLA4tWCX0OBiJzWWfwI2ND1ClkaD9SVBC+XHMonmWKsCGTT2rVd2+1y38Mt+jU/xyx20n7hmxfMaY+fVqSM4PKQwnAat4VGVIafXOPI4Hpu6imvkZVAsKjPF4LCUJQ62f0aOwYhQSlzSOMe4buy0RLsGFNEfKGaVT2YZ/i/3f6vJHDQ/wxcER+d8JElO/trm79a5kpIz7RUVajCs06/XNMV/DwfxfC0NoTigDgR0y4sMb4LjZpCpLpqwBqApchXRADZPwJtrELxFxKQWu31wLVQJImjwLJAP1UiE9z28qxqVsuca2tKHjLTWgLnpK5Dse6DWBLWHCnqwktCmjHxLbFMNw1yAAitVy01moOE5spEOQ3NS83FM7/Q4JURuAKenPBkQQj6k4cTgaQqhminsYjgt3QJj9zJI+A9hDZcASg4IeWmW/tumYssi8kvBv85pHomhFVElZdzXUy20l+CmLBINVGymDgp+puTvzh3WW2XJL98qF1c4/UprxfFBvAZdzP17ym8DJwwKzYVO9c9aJ2Dyr4O/Tp62mj1PWE89bktfKIyV2nw+1zmO0GqbkyFVBZGsGMhocYF179h9xsKhE/uZplVddZvo/BfADZQjV01JlRjGTq2sur6h5g/3fen4GekTwjelRTkrZbayprh/X6Se6cQAdJ3ZIEI3FLzKaC91EYRDgt/DYL+f+xv/rjqH9X5MOy9YUFiuFjQrMa/AgZ0G2AryYb6MYs+P6uvsGgKrb/PGizyVbt+iDBQAkI1WS0stO7ckzFyqzfzW7NyMJ/5nJ/5BF1/qrw4uuPRtg0owBCehdarO9cZf+ZB30f6mjzYcekdbW2r+kjr/Z8olFcJKMLUa3ivwoTcqf1OZvgHw4s+w0AjRFNcML6fFYiP0PfliVD1fYcsCiadFrWtBUXFzM553C+Sry+nVhQAkBKVn1WMK1ayOgVsbJIRQdv86HD5d6jgGGPLYvaj5VMqpfI9/z4+J0FqsbNYvM6wA4bZwDkxP+ct5JYKhJlWzt7vWz+d1HcdaONOSqKbYowihzIS8luHivaFTmVi7n5iwhPROARJ83VrnIQKo4GTNz/ZXPz8xbrlwTS2sU2wcrrtIt5s+PDhplu3bjaLT+u/2D39vuO5XZ6RVGgxR9bNu/etNh4klu4KoLA//YnTS14f1WNUQRakPIPbjpQ4qGqAei3iUnPH3M63YT1LikSG5jAHQ+gcXNfLiZufWKCn9+OasGxo9X/KLaYYQuM5xR5j66FcWaSB9mPxa7tMetp7Nffv/5mYkbxg0GBPdLVbXxHJ4/sN+e1i5i4WOxquLAJXyWjSWNfktaAoURzw0/pVPFOjuHkd64747YXlj35KiS8I+em5Vpc2XczAYQPNZR/pcTdZIJAQ7hWuJadSgfvvUAYG43bt6GutyZrTKkKFGIqs8eR94c5wFzv6O/UpREAh8FOeKxY4/NTEp4rKu+fp81T4FiIfbt/6AnjUp6Oi7WHcXUUEYL1grmruGDZf3/cuabFaUGtWiqyWLgrniLuZ9OzYU40Juuj5i4L9RRuzGC8FrhVG/mZ9Zym9kmJbjiKiXZd5JoGvWXP8o+/qlG2NGE6eJWWDdT/jWhvmpevy/GfOL5LfyD6sMshENnF/o2YcsX6e98x5Rdfhexwih+451Cq6pHHjQiZzidgOcd3JfPArqbtWjGtfuTY5iyiWxdVEcZf468IlCSSsgNdDFsA+G/cxA1+ui78JgT686qWrzKV/jGdszSs0WMtIahnxFEtF7AQuCGUNyHuycGKno9jJUa7P6dq3wsjJNhYB798DuJttHuuGnKr8UyRl7Y8eXkefnBdZp+Y8Y5rnBOPeV9sQq3Uacu/DeGEat0HTVcx8QtkJkTu5c2j05NFFJe9R8sqtURISgmKhsc/qBIi7p+qYFSUF3ANCL5cvQq6dx1KowbeMFMZMCLKcgFzX0th8weZqQOnAbgMz16aPasw9X2HwZVilJ+2kvq6y0hJK645ZQ1PbwDolYNVXaGSfAMjyd6a+kzSeorQ0maN84OYki5JsylgAsTyfxsZLLRvf4oiylZICnSJn59X+3WBjRthkU3yXuG4YGMx/7slVQ2jhiQ/PjUNx4VbejCkiocAi9/pMOASw+zmpi5CyOIRbwm0vEN89fZBVgdKtu+HG5qAoZfU51yYtVWuXX0jLDzZODWjLI8Dl1Dpo1CC1KmrsWmzEee7D88lYcjIrRxHZa429SgKRJcA0poi4c+ikEScVWTI4OZa76e202k6ZdUjcTDU3PV6sKCFGV9x3WApxcWn3wD3q80XY/siKx0LYz4mZSQF9hyvDjlmkngg/If4GglbzBmNWQwnW5rO7ziRWq5zg9lS+GWIziCkKFe47pvUx5pB1Dyl6naDcUH/5wdApAcx5LL9YZHwIrbrIciGbzALtkdgzgPyGUJDfsk+Egr39mlKyVmmLK6OxOEKXnzKOITk7P9BglREmzQXb6kQ1LkgD/ctDf7ECE4GRBTkBFSKa5zADhrIGXIRMbLgXtEh5oE1I/KVy/TwFpwDKgsYtAVhkMBVizpQKlKGgXqxIZzx+hlUUznryLHPU20eZg+49KFNAbb/q9vZ7PoQAiucV5cNX8lC6/KJklYL+wOTd56E+uYQ/bTh8g8PVTZLNU4uG9zfPUHtiCt29791rLlztQjPioBHWQiUBb278hK/I+XPIR7nWGTYMnskv+ibuQ9YG2RFZ7h8YgzXAvYIbKHQPWFa1zTYl9Tg1iC+2yWmCXVOYaS8xKXk3/VTlJTRfuFesorDMD+QOViLo++XzbtCnnzWV1RY/SwWlD0VNK9xHQGXXZbqa67pfZ+czyie/79z3TpswEILb96HMkljfxKCNNe4/96CpVQQOXQtCtcnTJgf3iVCwNxYULbCYtvA6BQtpAkqyHCqR2b/FtN4GHTMCCFJ6Z+w75qbPbgqS3YB/jfpX8jVhCGUBu6buVLpdsdb4bXjgvQfsj29+jBU5k1iHrDofPjS/uo0HeOvOQnS4+IQlkj10fUyZvjkzBq5JSfZY1pL7WXndVcLYeDlloBTy+UpOj6l+X23MoFuXLAs/JgjlkgJvMj/c7IuUsSKV9Ij7jjBvTX2r5D3uM3PWTJu+LIGVGny661g/leP/Pnjdg83QN4faLAOu33Ojnma7Vbezmy5KY0pQJKBvRn48l/zPBVkkLjusW1jOWgPvqqv5kocvhJTNVIsIYB3Hgnr9dEvWI+vGj+0SnhG/oF4sOLjzyp0LgZox4AKS6tOMie2vOUGa8JBIW1zacSzC/x333xL3lkuNLs8v/X3j6zcG2+AGArvfc2Wg8Ky47+EOe8PU1eliXGRs6MsQUZrcT+oXhRRtnuXYTY5Nlu+ZzKkO0R6Af4q4k5RYw5GKYhEjWmNO4MoJyV+bpfXh3CytFI4Rnm/gTgPrJa23QceMuH7f9bZaz0ycNjHZzxdDiu8x5pc76ZGTgvwb7ndBzJeb+jmBW2gsj4/YRrQ/c0FZp+ei+ABKf6+1t91gKsG+a+9rLt3h0kKMR4z2OwtnbX2W+cfT/8j8nASuuX3mZye5AtZXBCQLIDVzAfcEQb0qNwKEcqtdaI7f53hVGeEez330nDng7gOSfeTwRvh+6BhCWVwp8ScuCy7/3mSFTcyLk15UPwfc6+Sd8wAL3+PjH7cKuGy2bCKSSRGK+XJlR7ur2qnPg1uMA4EfT+IrZ74ccDPQ3MwOTs9Yaps2bmraL9Penr4BBw+haY/1pwYhMMvDZOrLr5S4EhRwLBm0Oc9m58bmTPlhSmEMUjLOcE1mzVtNEd90xU0to2m58oBxd2Ogtl55a/PUR08FPy+yYjNFCXXj1fxDjcSM5Innu2yHy9S6Uvt02Mfs2GhHc+juh0YPMfNy/64pI14QWuv+rcu+XkrAlgh3uClCwaxZCxvTO8OWtRglSNAXbq5f3l0MwrOSRyGQzXTc1+OS2Ust5Xu3gWbphZe2ZHH/9+r/FTaDasC1IGGeLYcZV4K+smibeRa4FTQlVgukwyUSEzrE2qQESme1aXC3waZnp55Fr+fJSAE7ttvRDNl1SIkwdNuNBYgTsWtdkAq3eSFzic2TuJVyEFsbfr/FAvtiQYK8fui6hxZkx+WjLi8ZM0nLjKXW+vPDVXiAXxeIzdzva7J1JEgWhRciM7F0pJaoKMfy5aaIpwaOC8SykqKUuMHvZD/mCaouN8AXBdVPAU4NAtUU8az+lXEEmsJRjdR7acd9B9ynFsi09+twdb0qIw02ZkQDAzyk+5DcfkQ56WSZupnkRGKjrbN4OQVjCXHjO8SMG2sDAicrWJPvS5GtGMGVnLwufu5iSyaU1zIhaZRnbH2GtZKk9B0WEE72KAncc/DowVXNzxeXDYrIG1PqTLwp0HzZtDUG2o0ioj236/flh7FGuQmZY4EESru+ef/aKSnJxLhoAXx5XHYPj3vYnsYBc4i5K20Rpk14RHAbdV+te0H4l6OISLvZSMtVRMQtElsb/hiHXGOxIEE/5ssfMyFIA1lBk3ItP/6J7D0/dotUaT+F1g2SRTmAL6PwHTMraV2FCMxC8N1PqckAAolh8AP5QyD4XRQR297Zs6zMwaUcg8t5kgo3fsePQfLJ7TR0W72bGscRa4eM447td1RJ/gQyxm46rxsgHWM/lnaEKnUjgybPrFvr9YUGHTOiQfy2xGhQnOm6V68zL09+Ofody2PxSp1mq0Em84RvJhTFULhVPjn14ANN2SwoeU1MgF9YS64pv9ns/dMXyo5Mejl5xdxCKeD+5z19XpJ148+b/NkMeGlA7lS+vKcc4VrIA07U7qkNK4XPnRH8bqBtkp106XNh37Ev3AkSXnnxla2FAMFINon2LLE+8eOS8sYOuUycCGH6wp+7bAi00WWjTEEsxbbcYFm3+B7QisTZzWl2I3soEPdIjEeHPoRyXlMesQT6pnnGzT25onxm9TnXuum1m8wZT55RtNmmplK745yVMRICB5JjNjkmOXYCa5jP9cMBKsuiF4qvyLKQjJ0+Vh0Dyjf47lEfeftCnk2LXwHyOuymWqVh9o1y2vHrnHEUa5PLVeO7CENpvn6bscr5TMUxGdSqWStTn6gpIx58f34qQoMsJGUAS4gGOfWkQoLMsMZQkXbmrzNN26XaWjrr0KL/+sevi7gj8BOHiv+VA6wbKWjWpFlZ9+T07QYszgtIZDvKiJQAqBRS+TYmjPZYc49glU3M0W2WaKMGsPXp1Ce4gfg1T0LB0VmAmybUFwjQcvhH+HyI+bMcuMX3UtbOsossW+hvSV0NBYIOenlQyWv0fbul2hUCK0OkcQQvpkDrh9Q+dce5XIWTe7EuQ/Dnzc1v3GyO6XRMgUBQqA9QTN2g7CM3PDJqJXMtgj4Hk2zAL37yorlk4iVqm5ibbjBwNcCzUWNJa5MLAvqriSZzDiT++nddczzzaVudVhTf4yt1LhEa10kB9yFwtcWk7GzReYkGHzNy4703mpU3WNl0aNnBvlYuwU8WnW9ev2q1UW2q4kqQl+QIcyMCoppjE0NqTE7K+PfYqEeS2wIzPyfr2DNKv6UElWoEfCnxKD5i5RDm1ZzKe10yd27a86ZoXE4s+FLIArGCpsQ97bPWPuaW3W8poYN3Ue31zlwio+Y/7/ynqG/8uBF//qQSvWmxDlnxUP7J3I9rwMWHGzZ2z392/WfRIYlrgVSXomzQ0C4s1Xwpm2VWKUhhJgvMfz6ZK1NnTK1ahXbXcr5jmeR+AGsffVCgrE+MlZN4wQ2W2yA6nytBLWYkAZhg4b/YYegOdhJoBaEqgVsEqxoVJitty28FB65zYC4+BU4rIeKreQF4FqoxXnniJxDIWc/IewidlOJ8PnkV4PSaGtcjEBeg1hcUxMvqIwQtfCN57tl3i75FxfmygJVCwMlSi8vxXTkSw+OSBS7WVKf59oFC8NKkl8yYaWNUvqB5sd6x2nBfNl63TxhnrDooYFo1ZvlMyvWJHfP7G+uH9hyhGBo3riGrUCD39AvJ8Sx5YpuslW3k+TZD5Mj7jwxWKM7DPYQF1m+TW0C1mooIuHWvW62yU65lS7iQJN6IIoKptdRIZWecQvN4fqLBKiN+bRomAeZ0f+FZQVxmN7kBZiglvwMjVBEOX//weXLddku3M1d1uyr58259oCxoZetJ8WMTT90QodPXqgRr1ZVj0DaBUBvELZiygUn59NjzaORFbNQUFhOTL4LbfT7terxPzSN37vI5+hRrVVawNQysVI3lhJ0C7nfcpscVAvmw7hBUHttMdl59Z/s7K2aCjVyyYzTGVNwqKf3PZzvf0NmcOe5M035AnWndR0gxyEJsDsjGq/EKCWOnG6zOGtP6AheZRryGq8aPscEF4hLKac8RYu1MUci0Zyn30MH37n7n7pL5yN+4NMuFrzRVG9TLeWL8E0kM1Rp81uJUlz/yS5IpmMcjvhxh6hMNVhnRtFA5HbgbGSbQLNa6GFioBC/6QpJFrdFY8zoMg3BXVIIjN6i8DPQNr99g5gV2Xq1u80gF47DKkqtkfk6sBlK2XqLSsQgI2ZIPjQlVNnFXsBOz4o+VW1gxVYjcvvft1jrhQ9Iw2TCzSPXcoMFU8iI/m4Z73TP2HpuuKJs+P6Tz+vEsflwIzwofDZtfVswIAX1s/Kn8PSdsfkLB7y0nbHcccJHEirrFNgz4cAa9NCiosGSxs7qQ+BItu0ZAu+lfuB1IqUyxIiFvYsyiwfbMnmUDdnk+QEmIY4Yfo97jkA0OKbkH46zRnPOcU6ZPKfQ/Jv0sen8XJ252Yi4LUTmbsd9ef2z5Ow9xZSWW5RM2rSv2mAcEhneZY53r2q6rmV8Y9v6wImV80MeD6tVC0mADWLWAPhYNpzIyVYa/P9x0W62bJevJW7nWx+UvXq4uGjRhjaET4WprCYy+pmQRsNEIS2psgRy98dHm+teLMwFCRFHEH0yaNkltZ4r/Po+Pn8+SbvvaZ68lfd5NwQzdwxJ9bX9hEV2/X903VH0Ul4AQRvn1f4QgTORjFnkS3CkhMjLXyuALfek/qbQag1vzwg8apB+O3/R4s9a0tcyhGxxa9L0QpbRUmZZnhQHXhR+jYPvBzMpVZTZPMCbrL3id2bPNZTteZk7a4iSb5bNl6y2LglZJeY+BdldKaqghxKisBSPicpS5xrqj/bgFpbglSA08DKWZS6q5yiUxh4rfZy/FohAMwn++vx0XyfTQZFbs2X+PcW3lgDFGSZ/x8wzrns37LLNmzzKPjnu03vqB9UGWWNtl2pr6QINVRkLC7sSHTyykcxJJz8mLk7Zf7hwLyrSfpiUTffmQ0wQLXEshk1gTF24V021X2dZ89cNXBTOfq5zYwDMvfVZTRHgOTm4IRAKeNGXELYtNmzlBEdxV1G+RKpg+8ZL4uFMWW1YKJs+EpYEN3g+C83P0Q5TKCFl+/P7XqPZjQoKFvOaya9oNxzWTyndk89HSYH3TeAi037fw+CmlLZu3tIFoPkLPn0WZLS4dX4HNY0VIAfdgTWnQUhnJUEPBEp4FfmNyrg/Qdt8yoBU3QxFhvflVtV1grq9Gv2rziGBq1oV2D+ZvLMUZ5RMuCxBKew09e57yATFXdpe2XWzbf4sKixAA+gG75VAShIBbtcOyHcw5T59j8sBnNY4d6tz4q/mNBquMaCdl/vZ5JdhYSGOTBcii5HNCxZyV567BP034p3jN980kIn0Rq4JEXItg7rd1vzpNfM5C5nsp+eVMfASjW9jJv+e2bbc1f9rwTwUBSr/5yoj2fCJ0IV7zg6lS673gmnHz7TXuCLhb3KySEH8B//YVBeEUoL9dIcjfIdZMnk1LI5RCd/6JUxQmSsfHuEZ8aBvDZitupm5g7vwhQ0yD9J+rUKMcgZSNw83kYe4yX/w2pjJ+anA5d/zsDH9TZ2xEuMoaWHWpVedbgLPWdoo7cmhJtUSFoCmN1cK1o6+15IRYZDXgIgyVdoDd87uZ3xXGRZNZLlV7rP0dWnQw73zxTtFrQ8cMzZQL0PbXF3p17GUWbLKg6u6hPANFG7XMoWoqTv955z/m/g3uT/782X8426y97NpF9YCQUSrjsGlsui/b3dQnGmzMSJ5od0zCYq1gY+UHP7hfJTY1yFKip30Iq56WVcGkxv+usUGmZpr4bZNKuHK6dJlZ5bM8K5MXH7QETmpBvhpbIUJXNq1YOzTwvNxXIsQ5HaNgsAn5AXaa0PcD6rTCWpxU3Sh5uU/IpcNrjB2+c1Jx/WfWKoMiYEkZ7X5rd/PkxCczn1uux/V9PPfJczZrIi/c6qvCokq7UOJSMsisejFHWXM/SzyA2wewjjKHUoI1IazKYq0F2sbmWmXk87HgP0qoVxqLkAWUXHdstABj/paKuCGI0jgvIAU0Q1kuVMyGigBrmz+GklXCHPfjCnz2WNxlMdnqKyLStnKyj2Ljmno94pCy5gdWmSUXWlJ978dffzTjvx5vKkWjjDYw78d8NsZs3GrjzGsxfmstu1bBsiwxWMhlP14IhYVb3zf1vmBA9vxAg1VGGJxBOw1KElL4pv3TMr/526XwJcjR3SxjdMMuna+/oENpWRRp0jbe1CwMXC6usiFxCtwXDgpOl1g0bOZJo7lWEneD8LMEJOguRGMs/SzCLc+mkKJ0aULMLYOedVJ1KytnbWwydixqBLb7zMwDjeSK60CrHgLv+9k/WGxgeIwpxgJ/Hvlw5xV1lwiWc8c1NYPEn/dcU7JRYK2VceeHDS0re2mvDntlssemHhrE4hAK6L38hcsrOqEi/FMULIrYxcZCFOwsYW+V7gqUJ8l20q5B/AfzOxSEapmHu16sBu0Lq7FL5a5ZrmDmdTNwUkB7bBXwHFsShJIEXfOsPrg3lmRkdxbItOE6zFkyjTTgCg+5R+w9qqDrzk6YoxDkCSM4LM0aXNnOoRnZHjuUUf07lKo9P9FglRHQddXsyGWyC9Amh707THXr4LYRrXP8N+PVU6YIBTlBY1FxTxJMlrw+Vn+DzIrAZ7HjzkHZoPqkr2xAhiUR3aM+HaVu3DwrcLMbZBNysx98HLHBEeaata4xQ/cYWnRfv4+kn0Lpg5rSxfP7gs9NdYwFN9oCVgFTOgqWK8x9unHgPnPImvKHVf5Q8pr7zPcfcL9VRiSrhRLfsdLornD1T6Tu8yJM7njzDqs4ZPGRsA5CNS20sXAtE/yblHipYSMgmDhUOyRro/Utdn6KrGbhYyMVHhWtvZXg1c9etVkkKKCxDfYfT/2jUHMKi5PqGk0Q9qG55ENbD7zGoYi+oPqwD5nfWu0VxpCxxMKjWTS1Zwgp+eKqJZMoBaxh+jc1c9Hy16y1t50fSzdfumhO8G+ehyQAX3n3wWdx//DsxMRs1noz9XNappGbzSVubu36edAox+c/+u6jpMMDsh0LMEjhMgmlas9rNGhlhA6PLXomBlVLEfKhKHxJteQz+9+1v3oNAZOAoFP/JMFkKVcRCUXHuxC/OkoQm7RmYXHbGKpVg99YNjzZiEHoNOie2ls0bWFaNG+h3ldOOPzE0gdDBawQYgg+9zuuwAwFN1KPI5Tai4IlpyV+Jh4/UXWtCbQTPJuktiEIyNba7bbdCkrgDa/dYAtZhcZmh3Y7WAEbOpFa8qtJL1m+AMyt+/1nv6RN7dEPHy0oQ35qtDYWPlzlz1WQyAbTQJvczCftffcE7hd6PHT9Q0vuLwHfuH+qDdnAsRhIO3Zqt5PabvnNGgr1W0jYy3pJ5ZtA2dOslJJhtO/a+6rfw2roHyie+egZG/OARY7fxMDEisLxDFCia1YWAAkZc+KXWb9E3bqsESwbrGEQcuueusWpJes+VI+Hf1P+QuLNYuCzWDx4ZsjCQvw92joiVkTihMTN7X9XAsCP7XRssnu6UmjXIHAeJTMUL5Saqj0v0aDp4Md/Od6setWqFVH0MiF3WWOX4GfmRZoWC/i2vW8r+AND1NPcm82QWiugGnTqLp12qGAT8N/rvVJv03e3vnaT9IMehTIfyGlr9OTRhZoTbjltSUGVInLyvVAf5CkpH8rEicEN3GND1EqA73jzjuaRcY/k7Gm9rW7AZuiZQN4555aE98FYhgoyZlGKa5AxpzJtFj29O99k7FGK/fsL/T2odtkAn0Lezz7afY3dzb3v3qsGPaKQ+YGZ/vX8a6bKDFnfKB1ahk5sTbhjzSalBV/Cd4TyGytPn9VWxvqojkeZIa8MKVoXoWwcP4uN7/du3dv0P6S/mfLDlJLvhJ6RdYKbJlQWIASembiYrOKh2hhqdPxuP6QE7jdO/Fw5oE+I89KezQ9QzyMDs1Cjg08AE2m3ZXeLBplmBYdO/n6yOffpc4OfCbkkyoVQ+Lony9CpHBcAp29QLtVw6FSnncxdS4T/HoQ6gI3Up7OWU617qiaWg2wPrBLURkF4yfuc+BGO8j3uN3X61KAfPBR3UDI2s+v89anw3STAd1/RNgjoyh1zcV+5LjWEtWRBac+UVxGhb2InIZ6DOcfnYtdPZc+UMceVgLVBxibG7umOfSi4WFymWWXeXcjJnHmmzRGNe8Z3qWqKCFi/5fqFgFDtVC+QeDTX9ZUCscC4AeYuQvPed1liFdGAi0MrT++3IQbmBLQDfmwR15XsPLGqhhh0N1xsQ/tbcwWHLBncT9xReeJQiPvptEKnTGugkPO5iMnYlADdJnNk+7wKthart3b9kzc/2ZzT7hzz/jHvV1URyYMGrYyALZfcUjXVc+oOuV5c4PIoh2skb3AXApNNjskqFL5ixtaCSg9Z/5CCCyAlwr1wL8Un77dbhIjmKyZ9MBRoCqGOlhGDEsPpzBXI/EYhQemQQCz/fb6HObmwSc2uM4nKc4jQT6Xmpo1aFo7mhgopY0AEZtYGmgI4ULRYpb8/9XdTLeCvj5Vxl6q91bI2yJhzXTZqXGAhlxBj9c7Ud5JiqiT1U5hPU4Q6FkaUItlw3UBrd/MU5FXq+bxLb0+7sGq584n1kjI/iPXSEIpDYUyp+uwDi6OrADRv0jwzPilPn2qQitixeKcQK/bkmcXxSP4zaoHLEsROu/MwaOOy8WWJD17XyPlipHvInhi7cv8d+xfYorV4NVy01YI21y5+/mLTqlmrqByY12iwPCNSKO/k94vNxEwC4V8IcU1UCkkRJd6k9/DemayeuIHETL3djdupnBouEZGfS+5GuIfKbQsfBkqY625wCXP8U53Gh4ByJtfzOUsISvzq469UJYbvaZuuy53ig++RHeJ+3rlhEfz+oZiaf03fVxpzQ4WUMWHizEv8pJln6bPtVt1OJaMT5bJSBYGAT/HXu8jDG1EO3L5yOSt8LhjGKJU1Fc4fgrStIvjqdZlrVw4dRWDezDZ2zq/ZYk37EsqoVENN8bkLZG0zTigFzH94VErmU4KIoa2wQbNZhtaCxgJLQcXQZ1nnoTkqgZnuPIixIPtBtZqMkfsSLKop8qSda8/NJhmDz0TsxjEJSWTqWnGtU75VUnBR14tUorcQ6Z7ITZRQV14JaNvec4JxXVn1wLsPWMs74467TKvIXK39ibGJKX3zAw1WGWHy9Breq+R1iT62he0CA80JRTbdciBMmky+Fz59IVjYiPvD6imTNGsDlB+NYZHPtVmijdW++fzAlwaWELxBaiS1QFyfLtD8u/gfib4P+TiFIEy0/IPuPUhd4PwNh0o1oZGfuZsep48i3/ScbBkgQYSawFyv5XpWKEvgntvPrjKTuoGjDMDvwPfs5jCsp+1P+oT0VwJaYzV+hr03rKz+EQp9BLkW++IqYX9s98ekolv/HfffZKVFC5LDOnbj6zcWvZZH2MpaIBZFs1a6G6UfBEksSiq5Wl5IkHpofm6xch2BYgyMlQQvaxDSvUGjBpnJ0yeb7qt3t8pEiHmXORxSRE7f6nTTu1Nv02tYrwKtOX3HyV7b1F2WYYkH0eJMeB8lWmMhZkwo4ujj3G3PNS2+Cgc7C1CoKePhH8LoY2SeS/iXCtrIdaVchKwZV3mXdTN1xtRgTA2HW/pk2Fh9rW7TZpsickfAGpTSEuc+c65tv09aeMA6B9Sx1lZJIflgxvzPoHHRYJWRrPS5xyY8FnxvneXWqehU6prFLeFMAD5fhmYGdIW6LAyJxvefD+EgJ4W73i6ldPc3b7FK+GyLKXUnxPoj9435w+eF9Sl2WgQ852173Wazm6j3IhYhOX1o/cf1RNgx/jCiQkTmM7oCbRPQgj/bLtm2EEyIEkgWgJzwsphuF2+WL5jbrYfiU9+7wZNuG3nNLQgYAlwqzOtTRpySFIDn9pW0ocewHqYSyIYcCoo9aN2DzAXbX1CkZJ/0yEkFa0UW2Vvo9F7p/GT8911rX1u6PgQsHCGZxZht33b7oiBULChaKQvhsUHJDa07lAKqA7vgs7wGQRh1bNzNmfaP/Gik2WrlrQqZPLi9ONy492XuhQoramn29rlbbWymf6XHR/lAwdIOYWT90B7amsfdGCsXoa0bTWbwN/d0WaJ9PD7hcfvD9zkkIZu0gxBKFT8Q18HmfMubt5hq4qbJN5mzvzu73mrTNNhsGjZu4hDyboQSRe26MvIUTeMkTOn11Da49Wi0SG0CANHUYxuK334CQkPEavi1CYZzryUZOXKKTMlWkH5CgGrR7vMD0gYgp/5QFlBW1lSe+7mbvC+MfaFE/0LRzUlWM8XGkJq9wj3O3PpMa+51C8uJNSJvxkEIzB0ENsJSTpOxNsGHIVamStvgmsJD8637at3N/QfW0WnDu6Cd0LNQTap2d76EMlrc7COgzY+Yuf763a63FlH6mIDOEB14KiRLRbJ3fCuan42GvJCNPCYLqLviF2Xkeh8c84F5Y+Qbplu3bmbBBReMti0mT1OyzDTLWSiYU5ODopBUkg3TyDSycUyafJb1pT0jc2S3NXezlbgrwYiDRpjt229vqolaNk0GEAAUZ8oDl/hK8vQ1Uh9xr/hBkwShuooIKWSZ0ehz+CNsiqAiQBA0kFv55eFj7JYh2nra6JtvJWI/FmQWMk2KlaYcmudKIcRHWQRzcuoIZU3labvPH+FzOXC69e/h8hwcef+RuTYJhB5C3A1c3muNvUr6AeBWdIngmH9YBYidqcbmKlY8YfDkeUMZKvLc3JtxqUYbJPsNhTOEBz940D43c+CkESflV0QCp/dygZVFFHzWHVaHWPaRBGJrXBYhHHHfEQUeGw4ZIWLGVEiWiljzQhl1AjcDJsamixXQf45q9nVKlhkVvENM0j5CZQoGdBtQkbybbWabr2Z8FcwMDAU7IwvuHatndcn3h3QfYlOXCZYddsAwNVi8PgvlNWjLSMoplAFigokpXwtc8q/jcyNI0CQCx/fJVwI3uLQcy44WoBs7ZdEX9x1wn83SCd2T75/e+XRr6hXLyp5r7GnuefeeQixEtVwzsZx83iM7wz8Fhr4DX4xvyRIWSYrx7XuXTiCl3dO3PuSZc+WcvF2+iaxTL8/EJgijZGgM3BMez0RmFnV8RJHtuVFP036Z9iXB0NrJuBL3SyHwc8bnUUuLZpEK3RO6byi18yJk2aoEPB8BuxAWimXh1C1PtQXZYHN1x8e18pVrwatGwKPb1yGODw5ouEVE/pVYJefERaXgqA2PMjvP3jnJMhJqTwp8vqMsaGtZruFazcspHnnH3neUuLg4WOHCDVnzQmOLa7Jjq45FLjRpPyzB4qLkHr1W6mX5XLL6OS9qlpEMpJzwrXDtfo3p1alXYXH50NJq/Yq8nEik6JufolouZFPPex3JjxeGUTZhn/cjBAQIiggCNJQee+C6BxYUEbnef979j1l7kbULC0bIu8oF12HBxthBaSt+bC1VUPsOGRt7rrmnWvAvVZBoNPQuUjgwOB3HeBFC7JCkTaaceiUDKaaIWIZTuU0jYzqv3LlwYmTODO4+OJP1VsA84xSWArkWbSCGAneAcJHY+j/tSjlgNJp+XG4Ddxqo9lWWIkIQZMjyQlv8wphd286l0s8L+ovgddey8M9n/2kLnGnxShxqUgobhlANRcTt65ClA/ZV5Nwfb/pjwSrJ31jiGJsUVl/BkFeHmPemv1f14qculb4UecyT1qpZqcSC5TMGh2omhdq1eevNi67BOsONF7PmhRSUW9+8tcCGK3JJ0qqlthSodrZcOWiwyog2cZmUloEvkQLcrYYaMu/5KZ7lkFJpiF2H58AlpJnh3Px4FtQaLdbI1R6eg1MyFhJt4d8y5hZ1Yo+ZPqboPnwGRYjYGvqaWBp3M4rxGch1sDQR4R9yOS20wEJqHxy10VElGz7XxFQsp++iZ8gxXNqG7IK5MnTPocGCXAQXnrONXpCLGj8h5CmYmAU5qbtuQuASTvF8kGWFsrtcEKtCMGUMUtgMJQdrH8GcrgAlHVQrOIhhV4jqxPWEoO3zUF06cN7+OKbTMSod+SpLrmL/LZvEiZueaP8eMX5E3ZhvdHRV+j5WgwnrqlaMUcCc3mONPUw1QSwTyiTWDjZFXx66lZtd2I35w4dVd+8bU94oUepCsAGg759iaRhSFYQskjPcFMQr3brnrVb2SKHLWJFDDRpnklQ2dteLll4dwkVO2rAcZHFjXv2KzmUV6jvpA9+FhlKjWeVpO8SU9VEgzzT0bBqpJgsXgJijJdMgZGZ3EeOgcDEvOBqyXEpLL7y0rfFAASnXXHji5nUC1IWW9ZEVGMn1iAUpJ13Ot0ZI2qCrqKQoRxo9tVxHfgs/hf96CkmdCBZSedsu1TZoBtXcPqEsHn/ObLHSFkXZOPwdc4HFBLKcqPw5TRG8R8c/WtjksvrWzSARcC1Yhvdbe79MN2OorgVZHXApaFkccuImgNemiis8OiGWUK4lnBm+29GO+exGlpZ98OjBJguidDCv/QrdbAhkOsgav3zU3ErA/OYEH+PxSYVbg8ldu8imLJ4Pxonvdli2Q0k2TDngvlu32bowJ105l5JRp7bRywxh7OBfCQXUA7uWH+pjuq3RrYS51nUBlXDFKC5h+pd6OW5WnO8qwzWIAiHXDd0nRNLGs7h9FUqvxl0qVuTGprH9G5eKFIgMMdL6faMpWysstkJJnzKXNGuxT0xZX9k0DdYyIifNQ1rVuRwYCPzBWeW9QYwKPcUCY08+Vep619SIb5+4BykyBljwNi++kbEnE8yl8AegvUt73dMNv1FasuIOpJicBCqWw8zoCvO8COX0W7eTVxk4r6JTuIeZZTchnyBNgpFjRf38DVmbMy9++qI9dUpAGZwzlZjgYaOVCsn42uV0mqqIgNA4osBluRklrsKl+HYx5fspJfdyWU5jPDq4ikLtlaDrUGAfXBkpEKWDdG/tvaxKtWxgPEvI1eODeeQHILsB8mxOEruDbEphUSateeK3dZk3lYC29enUp5hIbI6VDE6gSmLeXGUd60GsQrD/Hd8Cxpxs3b+16fdYP9UKDdz+lfRi95l8V5lUMGeu73PHPsHK2DG3ENdhnWCJCLnySWYQ9uHTOp9mLnz2wkxG2tRqxlqf8h6xIzFm2VoAaz0Wymt3VTs1UEwLVHUZKVMKUAn8FE8hBiIF8rLnwqRhWUWTJMAylLIn78eCGl2rgQRBjv96vDng7gOCG46f8lZJ4Fi1A+4wJ+MjnVegTdT82WD5DTIL5LnIKlpWrT589vBnzTUPX2P+PVkn0ssC4y9m5jxAoeLEKYLetxbGAv5c108sGJyqqiGCwGrOodi6k/TKUDtxJ2kpukHL2pyTuM/9QsaPz5dSafB3HoV0XnH/CHDLUmEZCyvKpFsYM2TRiAXeg9WXXt2891VpfAmHpWUXWTYzvTgF/v5AiniMu8TlDtEKfIbGukmC7Nba5soebd/hPe1+4LBWh5lrj7i23gJYG6ybBqBphwLFXGZGCGmgmnbNeDH2TZd8jIVmGQmPfL6EGIjAPGI4XF4Gl5iKLI4/3fenoGAgGFWuxQaindZiZjnfOoE/WiOAcoWTZoLWzJBg3eXWNW9NfavwulwnNcKcAnOfTf/MPPB+OjtrLLWzGqDNwooqgbhsumJy9omR3HbF5owU/NKym+ReKbj9rdvLVkTEUgFJVJ7NiOeijonPfiluLuZoyKQthFRuDSHfPSH9GXP1hJ6nLKvbnKwvzZ0k4+u6w1yLBin4GkLtkFIN7gbHaVrbLPI8iz9vRG499uFj1loWQ6WKSMqcJYjapUb3lbLb3rxtrmJrGtuAZBBzW2iKiLi93DVZCVeMuz+w2WeRqNFWjcnXVdK5hg+R3a7rz1rS1tpbJccTOgX3EOQzaUsfEIj97cxvCxl1XJcYtjW/rit/UF9o0G4aBsg3WYnAYaJhpqNoklSddIUHk0Qzr7oFoDghibkP868f1Qz4DgoJQY24GCAkO2DdA8wNr91gOQJiabYSjIp2rhX04zN5Isy5l7aw/DawuHwuATJRfLw99e06Cuk508yaujc62p6GOS1kZSH83+v/V1BEZJyy3FsogNBZ5wWcM3n6SfpEXHTAryiaN+sKy1TsXi72WFMPVPzXS/8ylYDgQr9QVxYwrmqZPG52USzzwjV/uxWCNdcpFsDUzbKSTZVYCbcP3Kwd5j7MuReudqEliXKD1lstolO2x/rTrYSN+yFEfpYHPDu1piQY325qj51aUES2W2W7iu8hz+RnpjB/IO7KA+YOm64Qqckmz7VxpeN+LMdtQakF1/LGNXzZjassFbI/5Kk95cpVcd8MeqkuWDTGBH7iIycWqpdLZs6lO14arEDOvuQWQMTaqskl1hOxKmIRZ71p8YTzGw3aTfPzzz+bE246wQz+ZHCJCyWLGVXMtS6HSCqTpMtHUW4gGCmgd+xzR9DkJpAaJ1A4V8IM6AMBx4k2i/lQO4Uc3fFoyzoKRGs/8eETS2rlFF3HNLYCrvmCzYNBnq4Jdd87941er9ruHc1FpwW+uYyUKZw1WjCxuDeIEcnrtsg6HXJtqpyy2Y6eNLoQZJwyH7SgYndcYu2N8Wj4TKXVYozNgnCqUKxQTtc+0/HgboNNz0512UYyhsQw+MAKGgpuldLx5TDCxsaXeIQ8rMnlWJMYdyk26M5rxkkrRpkFZINYoQvPYhqbD479wLoP8nKsuO4dN3jctcKkum5cV0c13Kr0tSiJszJi9HwenRBXi8+gneIu5frvH/N+MtNtXtR4RhLRdZmudiDctFxy+WOLiEkki87lEEllkpQTo88GmgfUlkG71kx8WsoqAVI2bdI5obknmrwBtVQcllS4mHavPRuWJhYEAkK0dhQr/MixPhs1aVRUEXEtDSdtcZK1HC238HKZz0IfZFmQYidbP2DVD7AT5tfQSSVkPZEMKJRJFwQq81ncFqRGx9obSpPmDAKXhw/JBmB+Qr7lWrBoD1Yn/3qSyRNKq2QDpnAaGQtZ1oFYECtCuBJFJG/guGTJiCKiBUhSbJN16AaE4+ry77vUQkvNDSZXrFyhmi3lwj1jploUaCeppXl4U978/E37m/6RjR1LbTmKCLh2dLEi4mZ5ZPH0rN1i7eDc84PHsSKIDI+tfaFJEL4Pyg0wzlqdsLygf1BQXUtNI2WtaszOUCto8Bm0/eSK0Pqif+sbDd4yMnz48CJtMLVeDKcOUEk9k6wA1WrCbbNfmlpONFQ7jVlZQieoXVbbxRZTKyfy22Wq1U6UWRYCFiUWKdfSkDfQESsTdTFC7Sfl9vlPni88r8t8qwWNhQLsbJsjaeBurBF+YTfN1QX3h3ws69QrJy9SvLWTVFYKt2slkVokwF8f7ilcs1zQR//a6V+FVOtyLCNaMJ+tXLruAZbbJgUoAihgWnZUrB/yBBmHLAvyDNomPa/kgLQ7y3rqWya6rNLFZhRptbU0+OmxlUKjGsAyIimn2hyTWkfa3OuxUQ81nV+s26w5N4DWLygJXLbSarJIy7w8bk4xPpQJ/8Cl1dgKWXN6b9zbDHp5UHAu1Cwj/0PVfAEDibYdOnGkxh6E2EDnBWin8DEgZKRWiWudELbLlHgBt4+I63AXaSpcjZ9A4RDoIy3dmP5jDFxFBEGV13WBlcm/9smbn2zO3vrsQsqt+7w8JwRdPsldCi9AKA3cjTViw6IqZ0iwc/0e99fRncdOi/bk9dip1u2IUlHSFjPL9mvopOlaSbAAci9tfcjcAghwPzYGIrdjhh8T7BPXqqXF1rAxaARrtG/omKEmBRJjRUyMxrIcsur4QcZZCI29BCSG0o9jAcUuIWDocxq5H/wdrAfmQCrYtImTQ0ZQlToFfnpsKjSrHf3tWgpsOYJWdZZAiYPQ4pPoVxRm37LYY0NdEQGPfvhoYc25sRmsaWQhchH5iPLtspWmBN/nARmVk6dNtmtMU0RO2fIU0/fhvkVstre/ebs6JzRFBEj196zYtfpEzTKiWEZSrB3iT7721WKzopyAEDwpMQh/3uTP5l+jSoMOEUArLrqimTJ9itl59Z3NUxOfylX+OrWujJbKTB/0frC35RPIi+M3Pd5c/uLlSZ91742ZWyM+khNPrKKta23AmtD3kdJA0HJglaDNTrSCKFR/I+W0khVjksen7wJFCSEjm2RozMSvH0tHPf3R082jEx4N3ss9nfmWEbHUuH0BJJ5Kc60IyVPXdl2D8TN8H3N4aN7nsSiwnnpt3CuaXmzrdXiZba7VK8t6l9IGrSZQ6DmkRokbo8JGjVVO+kTaCCQLyT25x1KK50fcTYpVQOtvN2WWZyDA/JY357I7+8/lW1ktbULAsijQsttcWVjuuiwHjRRrC/Nip9V2Mg++/2DFtcn8mDY/dk3bC38Xqb0DBgwwF198sfnss8/M+uuvb/71r3+ZTTYJR4BffvnlZtCgQeajjz4yLVq0MHvvvbe54IILzEILLWR+a/DTC+Vkd9PrNxUJDMvk+crVhVOJKxg4HbJ5silmadBXjbpKfd0tNIfGf9xmx5n919nfWmRCgYIx0HYtJdK1TrjBlissuoIpB0sstESSoGOhuRo5JD2a4MSHLenLIcZXN42UWJZqgesi0LTnQdEUpUdSfClylgI/xqRcll4ZTwnIiymP2rym/0mhpOZFFmSeaOyqCMSiVExHOeQkqz0b8xGSJ3zwYj525x8/KElBRWTOM6cWrkMJmPnLzGB6MSn3mMhx43Rq1Unlg6B9lYA2MJ/9/t6zw57m7rF3l2yMsMG6ipxkTLBhIgv8QGhLIeDJh5jLCOqAcmRJXsRcVxDENV+guZU3u6yxS0GZcMed7940pjjeyFW0+H3khkfa+YKF9csfvsxWRJQKzD5z8vxkz54dsJiFFJHCd2abgossBI2EUdbYbwm5lZHbb7/dnHjiiWbw4MFm0003tYrGjjvuaN59912z3HKlwYJDhw41p556qvm///s/s8UWW5j33nvPHH744XaxX3bZZea3CC0/u9tq3dSTu10Ms+sKt7nCi9+cYrJ8tVmBn7zPyRx/JQKeyo2pxixf2w4JBE6f2924XVGkeYy1MhZxv/NqO5vWi7fOpon3PDr0F8GSLscEGQZuwJ+MC5uHb3USttRqg+t2b9/dxsT4z+P2AX134cgL1WtwqqNglTzXCZudUHgPwYvJNWTCjp383fRi/N0aJLhU+g+FTfhunpzwZHIsAfNC/Ouam8ZntWQcudfU6VODyql8jjntKjK2Uu/0zy3vTWx9EC/ilzyg7pBvrZS+4nohxVJ7Xp8WPMSnkwrasOiCi5Zcg0w3noU54h5qUI5CG6YWBM3foz4dFVTe/AMTP7C1VmJxTcEO7XYoqStEOyAO7H5r98Jrj41/zLK+Tp0xNak9rlxDXqUy7Uo6q6/I+pt2peOd1Yasg2qjxPINWYrIb8UNU3U3DQpIp06dzFVX1Z3oZ82aZVq3bm3+/Oc/W6XDx7HHHmveeecd89hjjxVe69u3r3nxxRfNyJEjf3NuGoF/Ussy2WlmML7PAnOr2IYgk76awWwhl4krmPKURWdTZUOTBUvcgitkKIZGhoc8PyfBkA8z5iLidMciw1qiLaL5aT51walZIxxyoQmvwgY74/PCiU2C/m58/UZV4LhBtXwW/71bxyZVeBEDJAqdn5aax+8t1wmlH2tzNlWQlyvwJb1cTM6SYk8wYihNljo1pI7mqR/jKiaxa1fLjUn2BjELWYy0vqzBghqq/SNMza4lxZ8P6yy3jhnz+Ri9DxSiwpRAzlDg+WEbHBastVTtAFG5phuAzsEHZDEnuyymMWW3HBbnWB2qxnMsreXUGBK5jmUtJEf9/e1356b56aefzOjRo81pp51WeK1x48Zm++23N88//7z6HawhN998sxk1apR15Xz44Yf2oQ855JDgfWbOnGl/3IcBdBg/1YJcy78mi6T3Q70LGwFsi5DuuKyLLpikk76dZOnlGdhLX7jU9Hu8XyFA9fxtzjdNGjcxJz2mm8P5zDOHPWNm/DzDLLzgwqbzvztXZaNdeqGlVb/o04c9XbjXsx8/m3yvbu26mS1X3LLw97D9hpmXJr1kM002X2lz02rRVmbE+yMKAm/JBZeMXo8FPvbzsaZl85aF14a/O1ztexeMF6RNVEzNAmMDk+t1r11XMm4Ihf3X3t/c+lZpcGco0DW2cdK35257bmHsBQXLhSOUJegvhP+8/Z/CNfjsC5+8EFUgZLPwscWKW9gxWaTpImrdjlQ0a9ysML8ZEwqXiRA/b5vzzOlPnl7qAkmcV+XO9V9++cXOBebP8Klz5w39tPVKW5unPnmq5DsUECNzAEUvtB619okFyTJdbnuBuWLUFWby9Mm520wsQ5YiiKVioSYL2Sw1ra/fmfKOfW7GwpVVIRy3yXFmg+U2KPzNd7U05ZAiAlhDqy69qjnjiTMKbRFWVLd9B65zoBn65tDC39z7sheLLeDM61jRR3G9uAe0HdruYP47/r+mHPhBspZ88YGj7Tzgh7RWarLIpuzi0HUPNV3adCl8Bnz49YdJsieGtZdZO7ifWMw2pscGPczH335c5KJaq8Va5t0v340q0ydtfpJZoukSBRecL0e1/e3gtQ+271VzfxWkXjOXZWTSpElmxRVXNM8995zZfPM60y84+eSTzVNPPWWtHRquvPJK89e//tW6FxAgvXr1sjEkIfztb38zf//731WXz8ILL2zmJb746Qtz1NvFqZksBoqPvTrtVTPg4wFFn/eDxTZabCMzetroos9Yl8NqF5qT39dN4tQE2KPlXEbNEV+OKLlPOfhrm7+aH2b9YEtDSxXX3q17mw0X29A8MPUBc9/U+5I3JXuaWOta06JpC/V92jzw44GFfji01aHmxsn6qd/F3svtbQ5eoW4hvDf9PVsuXOt7uW/evtliiS3MyW1PtuPKM98/9f6SvvDHO4bdl93d3Dv1XvW9HZfe0fReubcZ+fVIc8nE0qDXVOS1WvAs3ZftbsdzXoJ29Wndx3Lz0J+TZ042rZq1smPDuMg8mx+1TcCQtYbYe2trNoR9W+5rDmx1YK7v1Ff9F+lv5ih9/cGMDwprKnWNhdbtmGljzJnjzszxZKZwz/YLty+MO6Avx04fa/+95iJ1lOIyN0Cl/cwafv7buan10pZKx+6cdueYdRdbN/i+NsdjsmeFpiuYST9NSr73Zz99VpCZKZ9x5wP9HZMxfv+IHAWh/S0k2yvFjBkzzIEHHphpGZnnysiTTz5p9t9/f3PuuedaF88HH3xgjjvuOHPUUUeZM888M9kygivoiy++qLqbZsSIEaZr164F0xR+9B2G7lDy2aF7DDUH33twSW57ajQztNFo1JAkueZCTlk+Fa922kmt5+Ln5gMsF/AG4F//6LuPzOmPn555wvbfv6DLBabvZnUBmwWzeNNFzPSfptvfvjUn1d2EZv7BMR+YER+OKOobv++hbOa+fmHD1Ou7EfLuSUj6W053Kde6eczN5qynzipt5+5Dbe0I7tF+QPuS/ohxWQhilgZNwFyx4xV2XDHJbnXDVvNcCRBOAs19hpXsuY+fs5axve7aa5660eiLccfWpRuH1myokGCnFTrNXWehk+lvBNLfwJ9TWRtyyLIoY9X5hs65n13kijv+IUsyKGfNprThmcOfsYRrIZlRznO48J8J67a2JsuBWKdjFvAmgc+482HVq1bNdV/2ILZ7ba3c2P1GM/HtiWa/rvuZVZZexVQT7N8krlTVTcMFmzRpYqZMKS4Fzt/LL7+8+h0UDlwyPXrU8SKsu+66Zvr06aZnz56mX79+1s3jo1mzZvbHBwpDtf1Zct0pP0yxPrQlF15SJd3hubWguBRdjuutudyaZvv225tua3QrIh0jiMz13wFNEYE+fsBLA0pM+5Ii+dOsnwrxCOL/fHzi47kYXi1/Ro8XLBeDH0iKDxto9PWaUEwVclznhjduMOc+c25QqKAEzvhlhlms6WK5BQ/XnzhtYoEwid/ybwF03oyLxB08Ou5Rc/oTpfVtqLNDn2qKCGjfor2dS1xfy1wBfpbWzW/cXOhnlFKyphCQjZs0VoNL+Z77/eMeOa4gMEmTfWTcI6YcpCrW3NvtT4E7LyQeRp4tFfC6vP3F20k0/syDga8MtLEsHVp2SLY0LLjAgmbkJyPtWmNNW8PmbFNUtfr/Xv0/M3j0YPNbgPT3g+89qMqfEIQLRzLRBDbtVQi8nDXqz8cQ+M7Ln71cGH9LA+DIK36j2LOemMcTvpuQNC47td/Jxp+lzBfa8NPsnwrr9rynz7NcInlkA58N7SfaM536RDpXiwaZnyILZs4qzezyMw21z8h8yMvIwf2XaL6Ercju72+8d/gDh9vXzv7w7CApY7lI3bNzKSNNmzY1HTt2tMGou+++eyGAlb8JVA2ZaHyFwwoBj7K4PuFrwX5gIb/J4PCRetolq0Y0cCEd4ztswC5zofBaaOmHpOFpUdOSIkmA3a173lpISQR5gzyFOMjPJgKkaPKeptxUeuqBgC0GybqAxbOc9EEtHdWHm+oG54mG9Vuub/2wIdA/AvqP4od+iqifpXVul3PVWjUES/rg+W7d61ZbDt3n7+A3SlS55mu+w2YsnA9g+1W2t8pXLOMA+PEH/GZTk6BJgkpTKu1mzQONLIrUUPri9M6nF1WBDT2j9JmWadb/hf6m2QLNkhSRndrtZB4a91DZMsEFbTlv2/NUBZj+5vnIBMoLDhWuMhJiB6bNjBWflflIhl1KoG6Mvh/EsqnA+V3OL5Q3kOD1rHRj2uvOwbyKCODzbhpv1jNVCsaYwoVuaYFgvzSKZ/MwNqR25wn89ue+mxYN/Ew45NT8zsDJTf9JWu+1115r/v3vf9ssmd69e1tLxxFH1JnlDj300KIA1+7du9v4kNtuu82MHz/eukWwlvC6KCX1CfyCvhYMpwibiEDqu/g4quNRRWyBIaIjyWbQhLbLXOjyWrjg+ve9e19w4kmAHcyJLGQUnnIWlLvRMBGFgVCY/0jDiwqJecgmi4BrsbDu02RBHbjugep7WHVc9kaf+dQH72uCn75hHsTMqtJ3wqbqjodA+tVNAdfSNLV6GVIOnc9raZ8opgS9lQMbbLjpcTZTg8ywj0/42Iw4bEQSW2NoQ0IRoa1YALWKxD7yuCELade3drdzk4w1XHlurSWNEdgN2NQ4d7IUGskau2+/+8xFq11k2izRpui9DZffsKjPUtmMN195czOk+xC1UjBjXc5m6zL9xtiB6UdRpGU+IrMgGwzVIcqap2yYsgY4dIZkAwGxsj64N9lR/pzbdqlti9rBM8h3cAuWo3y769WXDXkqnaeCPuYQ4a77EHPyrDmVfQGHTB+njDjFcqr484yK6KFaVXJdbe5r68CthTO/kLvH99tvP3PJJZeYs846y2ywwQbmtddeM//9739Ny5Z1GREQm02ePDfK/IwzzrCpvPxea621zJFHHml5Sa6+Wqfond8gQEkT6ikbORo5pwfoejWhgyLCSUOQoiD4FN38ppBWav0N0Wypb5J3QZ2w+QklKYOpbh7aiVmYdMt5AdmIfYEtGn6of7AwuFTrbrn6POUA6BtqtGjwy8vHClW5gKob5ZPfPrJom0ObAK4kAqLlvZTN0G2/rxxhJRMFxaW+z+JJQRngRC9CHvdT3nIBeUA/3zP2ngJNP6yqbpG/FGQV0aP9sN6Svm5jj2aMszwdLkZ/NtrSlUufaRu6hnemvmNPozDZsob4od4P/V3u5ugTGsbcAvC6+HMUSwl9KP3Cb/72lVGsuT59v09axv880/W7XV/UH7I+WAMyV9w5R3zEQa0OKjkcFtZUGUZZdy1pskErWBkbw7WXLS3Ql9LH8pywOfvgGaFO0CykwqlEHKD0E/PmjD+cYd3/eVCJNbnaaPB08Dfee6Pp+U55lXOzoHGPZBXhc2m3JYahnAqYUko6k3zMAWZENyc9tUx2uaW1fZdCiF9Ao+XGnAvbaqzEfajAmsbVEBsjoTsP0b0L34X9d4DW3p8LfjE/l6PFb4/mxtE4EFBi+3TsYwterbfVeta3nDJ/BnUbZHp16hV8X+MlSCkKKOMrjKxjvxirUuv73+HzeWJNstYcc4Ux8dvp3svdRLXn4bMoeudtd54aNxUqZAio4Jz13FlFFLlnj2H5rF5uAcOY7PHHSVM4tTno85Rg/ULpDK0TxobtRnuvkMbrtQEZffotp6uZI1LoLkum+s+KNTuLxwXLi8xtaw1aaXOV50fKCbDuY2UoYn0cKzMw7IBhUT4S4f9JmZMpfWQza7pXN2akVigvEaQzEf2dYlbNc7IT7dI9/bKQY+Zqv2AY36dAWF5FRO4tmvdZW+sBl/6zIbBdy0FqmWziGGTy5jnFUSHUPVFx6vJL1lMozD+RizmXLJJYVhAWK63AGpsPpcrdsu+CwS8PDl4z5joB9Nv+d+2fedLQivnxd8hCorlxaDdU6ihb1g3YyNgNj4wLUhDle1kmfp4HGu4YqBPinx5TigLKe3L6JTjU7z+tWJoULEMQp3w+i/Ya957Wzr5b9LVzC2Vy6F5DLQsq80+7Pt+HgGqfO/axm1Ts8CLxCAI26JQ1EbOiwWabF26smjBCh9obu782BzWeEuRcbJ2gGEsMifbsWhuI59MUERlrYW52rTeQxoXmiFDqi3Idkg3u3Oa3pojQBjbuMx4/I7MeVqyPeYZdVtfXIDIYy1PIaofyjNwIKSL0A/0RGnsNWOjqA2XVpvlfQ9dVu9pgQ8xesTLneZQCzPpMUv/0i9tGSlG7E+bMrc8sZNeALE03BN+cz+8sM6KrNctiQfilVPt0N2O5H37OLJpx7tlv6372xz11sUi1wM/ARYLXxpQZYy+UYEk5KWEOhS1XixmQzQWBrGXJuO4ZLTjQpX8HKEgaqEOB8uBaHzT4J1JpI+A1eAkOnHSg2aLNFpmU1gRQAyxa2n398vMyP9i888xNiSHx+w8XpBuPxXNAEEdWF/3N2MSKwrnYsd2Ohfox7nNofSBVfDkBu1lAzN3b9rqtzgT+9QTzz+eLhbgWO5alFInZn/pJWVlmfn0U2TSfmPBE5n3dZ/NLKQCUd5+JNBQvEJp/0h6Nsp1ng9SN07r7vNxn+7bbFwVQxhinaQPWLNY/8XxZMk4r38Gzhqx27vW1tZEaSM0hjJT6vBYrv49Zzw8E6kqd8/Q50XXGe5R30D7Tf8f+lmqA+7C+U8BYxMZ/XqLBu2lOuOkEM+iTQVV100iFXLfugmBUj1FFFXjdzUSEIUFxB9x9QLRNWamhLkImWlsJc8wt6oLFj6nV7Nhv7f0sE2mMQjnkqimYKgOmQD89NCvFLMXtVQ34ZnfNbJ35zM7zcJLZZMgmuc3lcu+ULCm3j113Tiyl179vrH+hNb9y1JW51o1LKZ/lgpSsNsk0c83rgD7UqgH7CqYoWG4fiEsmts7yZiX5qZuhsSMN9ZrR1xQ2aeDex3Uh5j2QSCXxLqt2se5WgOJA/Bgpndqzatw1UsXYR0p7pP3+QcwH97lt79tKigEW3m/U2Gy/6vZqqrrrFo2B/oZGQXPlWgK39Q8NlmPIgjxnlntGg1A1UEyVwn5Zsj6GVFe0Jje0dP6YC3te798NWhmB3rrahDwijL6d+a06SdnM4VEoZ/JJTQOEi2tJ0Py5CGtO4J1X7mytLVaQJJzMUiY4CMUxxCb+yMNHWn4A7Xva5iKL1udKiMVNxJ6PkzYEWXkhtSxkg/H7NvTMPtyFjrk/dsoO1SDJI/z8supagUEf7maUEv/jKphYGB8d/2gw3sN/pjzxRf73U7/rKliyVlLTVvPEOhGo6td+8eNsfIsWCpNb6M9VZPLWX6L/T+t8WlG1b5D3Gf25LsjTHmKQIJNLje/JI5u0xIAQhFMlVnAxtW9Z6898XOfydccJi4Z26MxSaMsdH61eFgo+adzSh6HDHu7WmJWR7zF28LdUE7WYkQQgmKqliPjxDUxeDeUqIoC2oohkpYYSHMnJm02L32x8xBdgrUnxXWNxYZMNZXOE4hh8s7Tvt4UxUfM9E+DHCVkz+6KgxLJf3Mh7FJeQr5jxeWpCaa2SFLjR+37f8jfA3O/q9Vo73OwGqpPG4KfXSdxGnlOYew2Js8kafzG1AzbRrDgpCfDDLfDfQ/5bGAuCoUPmcUHeLBH3eVLaZp9n9iwrpIU7BmWhEkUEV6uWYcJ6cee2H2eDu8uPsSB2AfeClq0Uyn5hs8D8zobstoH+dwty5k2TDqUEC1KpApATD37wYC5XFs98695p9aEAz5mVoo/MwKpHHFUlMn6zlTaza+Kpj54qPD9WNRknrHshMD/P31Z3FZc7Pj4o3IkcgqivsByUZeEqIpb5e84ziPyEnRVKeI2td36hQceMsBhSzLExn7tPZiNAOG2x0hZFgU9rt1jbvPXFW2W3NyXlSguO5ATOT6rpGdfPMZ2OKQRIaic+zItMesm+8U+BCFlMgLJBc19hZiRHHssCfnkq+8ba5JLwAD+jwycsI0BYy1zotnq3oF82dSO86bWb1MBT/LJqvIgSpyDCKyuWwx1rP26j6B6RMgGh2IUsSxJkYlCmh1KZfXBvBB2Kcvc1uttNOUTqBO/KdzO/s0LQb0+e9EgJyMyKTQI8I8HZtOeoDcurkyJWSQk0pHjaLQ/dYg7a6aASNlotzoY4GC02QmKRQjwzvmWSYGOxsgh7LL/pl2q5mmkXVjRxhUhF4BQXFZtcSryYz1eDHEmVTzxnVlxLVnB1CH6fU6DSB0okwc7cPxbkz3i/8+U7udugIcvq6+4zPnGZPx9FEeYZZHwpjzG9aXiM5wcatJvmmpeuMUcPPzrps7GFovkwQ64KkGeRyOKI+aJdENGe14cZu68fR+Cnc4rv1WWRJe6FKsVaOwgyhPY5LzBFCt193piKvP3O6VNYclPQZ+M+ZuDLA9U2u4ymQNqOoMCEDOsn77v+WxHqxDywwYfiKjghU4VWSyV2449EaXRjCETBpA2htNNy2FxdM3/I/K75s0PuE5mHfmyVjD8nvjyWjtAzQUW/aLNFrdKgjYfrPqEPV1l8FZtC7ZdczxvHRAxZyA2ppW4TEwb8OZ63dlUKUtcNWU/iOg6l9brw41KkT29/63bL3ZSFUFyDG1yrrYkUIMuhDMhyM0lacV6W67xonBFbk9LG0Hzs1bGXueaVawoytfdKvU3/Q/pXveRK6v7dYC0jUn8gFbEF6Z72YmbNvIKCgD9of2PxGf5CxAedB3/e5M+25k2Ji0ShBwZ+hDr/dq0FwgYbQjmKCAtSFBG/TX6faKd/TUjzeo+NetjF6GOZhZdJzn4AKF4hRlN8uj5tO30oGx0CH/eebDKyKbsm1VCAJxYZ+bevfPXu2LuEM8MPkOVETpmBECox8zM2rIfFmi1WsjH42QRi2VJN3rONNXX3e6JfScYX95CMkVSFJNSXPTr2sG1w1xtw154fYI3w7ma6JZHmhRCzOEiWCG4z5j9KI5l4oZIRpE6HShmUg5TnwG0VSksNgbbiruMApx1u/IDa9s3bm/d+eK/Ijaxx7rjxONq6yVKuJTPwmpdLZYIP1ijn+HmpiIC91trLtol5ZTPLRpySJJN4VlEOQ8/slj3gOai63fe7viWWvvmFBhszUs36A1rueF5/uO//JioewZgVnwFcFsE/3fenXG3fs8OedpLH/O+yeZRLvQzKZd9EQHAi1PgAQpTFbhwJvmitzSzoSdPC5b5T/dhQkKPMhWjoNdp22uP69rGOAOGWKWGvjHBIaEytmy2xmRnw8oCS77qbOYrW+U+fn5Sqqo0lmVgh7gN3bLDIaJwTvrsRC4dmAWKcXEXEdyXglgwRlaXAckXsco0ag+X+W2PWRXi7dOsE1WIhSJ3rqUyXviIesmSRfaTxsmhg7IQRtffGvc2lO1xqf6cCNy5WHY2o76B1Dsr8Pgc43Afa4cadyyii7/9Ql67tupHpb+lzn2cjZCFizVDmAAXWZ+Z1Y+LIcskCFrQ8Yy2xPliRkEvE/KTgzrfvLMh25jlFUVP2FWGspY2pYK1R0by+0GAtIxIA558cqXGSSr2eddpDOMTS2/ysEU6pj49/3J7W+Rny6hCVrc+Nm9DIh/KATWD4+8MzTwxiQi8HZ2x1hjlvZHbNDw0813KLLKeOVUyQy2YSK0j1wPulMSRu7Q3ZSH2//b3731s4Mb/35Xvqhi40zlmxIf7cCSnJLi+DzyHh8iw0bdTUbHnDliYLsslnQTtN8jf3/Mumf1EVCL/GUYibRRCLiZH7acjKDMqCWyBOg7vWtHER4e1Wx2ac9uqwV6aSF6rzU8mhiY3HtwqiyLdctGWR5UgsY2x0KRWStTnBpugHoheqASe0N2ZBvWqnq8yay65p59A7U95RFVGxFsWshz7YzFEusThjtZT0cj8mjrinGN+UtIHvhWLUXLixPnJ4JAg3FbMcRfTCkReaf3b9Z8GdGPuOTdDIEYXBfCF2pL7QYC0jIW1yy9bZgjzllMPi1KrsamAhkZplTYRzfHiaxUWroxASVqKx0y63gJhGtJWliMRosrkuptpYDRDaV+7JVUiwNGCpyYqql80wq+6I4KKuF9nfd7x5h72+WwhRNhDM0os1XczSNGtxMdpmHKtz4dZx0WoKWd6a/e8r1FwRrg3/ORG003+qXhBa0EU0J5CUE6TPWOrWuRGE6tvYVOU377BzK3T/eQm3QJxATtt+NgzKuGZ1wPLlW0yokWOzXSInWJe1OIZUFmRRzrkmChbuQWHlpX+Zx27Nmw+//jBTEQmx3bp1YvzMlWpYm3GTikVKkgxibttU2cLnUJ6l/gzXZvy0dGwUltj8kzXOQckH3wvVlMpT7ys0Z6dMn2LXEQeSoOWrUV1l41QLPX3au3XveiE7Mw3dMqL50pggocqweU85WYWpXFOi+Nk1VkvX5K0VYEPwhE6vWGa6tO1ijrz/yLImP6bFjit0VCnVQffVu5uBOw+0z03ef6gGyPnPhplQU6D5SLkH9/LJsFyIYMFqgOUpJQCMej5uwJdcn9OzKBhsoDGB4vu0fYZIt+6FPJ9YGITsS8js5H0UH4nzcJ/NzyxKzRDLwh/b/VGN75FrS3YKbYIQTlJ2Q6y5bsZTKoHWPmvVcbHMS7+8G6cSahN/k33APHBPpPTDnnfuqZ7cIezabY3dgpYjl7U4NJ68lsKCLJBKtr7rQ9rvcs7E2IklKPvwDQ63Rf/8mB83m6WSzBUNzCmf0blP6z5m8CeDC5Y1GI01a0SWBdKVtV//+HXBHSrz2H+NWkQXPnthyTVdjg5tfDjQ+LFHwnDMAUdr49l/ONustexalk31X6P+FX0GFDGUTX6H+p22y3xKjX/bcLENTX2iwSoj2omDCUjUcl78a6d/2c3GFSgh8zzCXAuclAh+zS3AhNYmsZgKe3bsqUahY5lJtc5oGPfNuGhWyYPvPWjMztk1QOYluB/mXk5rrutCY3NNoal3g7rk+iLIXerwGG56/SbrU3fN/+5m7Kc9y30A10YRgYfEFUouTT/PxvzxM0s04V0u/jvuv+rr/iZHm+ibGCNmlmsxxqGQB+UoYdQ+AVh5Ym2iL3G9ofy7Ckbofig5obpAfnVsf64yT7mXRrkeAvdhw+GgrN1TOF5Yo1w3C2SHDXp5kI1dC8kkENpcy0lbZfwIzvXRdZmupu9ufW3hR7mv7w6yru4jX7DyMIvUjr5w3+c6PqU7r/3z2X8WKaA+yzUKhvbsjJ2sdz+wNtSmfzz1D/teKndOiAKe7+MmxA1EaQuRDxzGYgUz6X8q2NcnGmRqbyj9ztIpBzb2LGi07piyrTnR00ity6DRXF+gXy3S968Drc4C7xM/UAmJUwhaGzWgAGDSrAY9u7iE8MPnHQOpUAo0imWujeWpkpQ/gu5SBa+7qfjWizzMpilwUx0pcTB8+HCz7AbLms7/7pzZ3mpYUfxKuS7cbAlJ+4W/Jg/zajV4GLKwQ7sdVOpxP1bo0ucuNU9OzGbxDaV+ammt8zo9NJYmnYJQmnPetOrQtf22uOnvT49/2jz90tNm605bm63bbl0Ud+HLRArCiYVUqOBTmGBTxlHiS9zaUbGqv/L+vChX0STAkC1lSPwqvykU/XZcO1xtDt390HpL7W2QMSOhdCdeC22Cm624mTlyg7CP13W7SHCW9aEqApLX0LA1v6LvX2dBambQrFiOSoAw0DJYNMCjIXEbQkQVAm3WKrFKZD/PizCBMj8vaCtBbQiH/f6zn2pFEsuThiz/sJsBk9oe5oAb3yNI8ePmGVMts4jYkaz20u/QmJNaXC5cIjcXEg/ibhj85u88WQguYt+BCr2SGBMUkdD3Gf9NV9zU0n6nKCJuRVk/04nDA/JH1kw1s/oYi9i88mMs3Erlx3Y61taj0mA/P7tOIZeYH4KOTxpxUlVkj+YuZ56wkR9070Hm6k+vtr9b929t7+taF11YmftcnfuGvu/VqZcZ0n1I2fNC4i64Fu5bNn93PWvj67rr50X2YeM5MVkaQzYU8DN+nhGsRByzkp+77bm2gn19okEqI3nSnQSjPh1lSZGqBXx+WlAfcFMKiVDXhBWuHk7dqYIMPpHUQCbMnallz90US078sPrh69euO3CngWaD5Tewplh/EWHml0WcNy1aC2rzwX0mfjuxyDXCPThNIWR9weYvfi1FNRV+ILIvxEKBgnmFJuAeY6aNMYs0XSSzvYwV7gnhOCkHGmW/BFqjFGqxTGSN5SlpDugrGFBD/USMBpkNlUDbOCxny8a91RLyLpGfG6DMIUHmsnu4QBEhxoANjY2WMghawHIMMYWJdZQarM2zEkRLu1BISfGPrTvGedlFli2c+ENBx3kQs8qF0nNF4QgpcbTLDWqn/4lpOmvrs6Lt0ICLKpTWLetZxhcZguVV+JjmPETFaOzIKAk+5h7IWr+UAAhZfqlEHNsrFmi0gPnipy9MfaJBKiOY2vLCrdlRDeDbzOIQYbJT5EnDkFeGqIIMoeQrA2S7XLnTlZl8ItY82v0aq3XnyUIhxZL6CCJkqepbdF3SUVe70P6bTUqi7t1aPi6y7o1biGwFeRYhMIspIqoVaXbdhowfXfvu5ittbrNYcCsAV4HIC9964W5SbAYhZSgFwjmCEtB+QHtz5rgzrYtmzzX3jH6PFHbGC9dgJdYR4S1BIU2NB8lLzkecBVlMmhIjloiQAs38SOG+0MB80XhkXAzZdYhVNKwbxMyyCoernIX4Y1gHKHKMU4oyGtq84a+QdcQPbiAI0GKgT4iPI+5LTvxYfkLj5qbShyzLeRRqxoyxLEfBl9IDGmg/sTHCP8JvcFTHo9T20Q8ouRr6bV2X+q4pPnIIY77f9uZt1oWLIuBaQbdYuY71uBzMdqzsxKwR1MuBjbXqZnnxt7hIsSaVi5MeO8kc9fZRhRiq+kCDVEbKOXlXEzGyI0ktlKC/WBAWAX7+SZ9T/B373GEJiRBSQkzE9WL+XbGIuIpB3gJWoRMNAvrznz43vYb3KhLGBKGFnj12b1LbCNBys1GufaU4xRTwNyci/KuaFYnvoSCEiq49/8nzVkDLwgeiQGjuprzuDFFGNWK0FNDm07c63XRs1bGE+Infd79zd+Y1JLuAzauSNSEWkpAlzw8Sp615+g5eCIAbD2VU2uoXcPQtTn9Y+Q829umWN/NzBwlipnbaRq0lV9GQk7NshrKWtX7hNTKGUsz5p3c+XT18wMTr12qCxCzqsjGz7AEiNR3XVZZD1hzal6KQiPKEQlpOyCLtDTEHc38UA9asHJBk09YsZ/TDDz//UJo+7DxfaL/gEIbrCHeVO/Yo5lI/CVqFSvHrnINMzEKTl/lXg9QPy6JLmFdokMpIXu6JSoCwcHk45JTu+o0FPo+Ixm3guyX8k76YCbFuHL/Z8fa3lJ4PTVYbxb75iSrzYMg9sX3b7XP1wXe/fKf6hgky03gd6AspnuVDc8e4hE7yTGKeZJPU+tL17WeZ+GXhA76DYuFykGQhVoE4lUvC7XtMtqQQknpIn4WqHqdAsrIqsfzY+82eZS15oTkrbKd5lC9xP7ibLUHTmKtdF6cossx/sVIwJ9xqqzIvqEODks4PKZWVKmFaZgN96sYYxNZyCK7lD1N9r417Fbk4eZ00Vw3VdgVKOi/z1w+ctIH/G/W0FW6zNkTaTD0lFLhKUoJj1iotNRsFAQunJgPUA9TsWQXLh9+XqVZ0vnv32OwDQRaazJFTmqIvikpqFessxJit5zUaZDaNYPyX482Jt59ohn0xTE2DZOF0W62bytSZkknBCZBJ/tG3HxVZJcTc6nJkhCKzrZ/ZY9uL5dr7mQ1ZfA5upHyoAN3h9x6exCTrXpNrSUYQsSLvv/W+uWRiaXtjtVew1MTS0bLa4H7P70u/8GBqVoNfXAoTOwIn1r9+O9wiX5ye8xbACkXNlws/A0Dq47gpjV1X7WoeHf9ooe/gUiGFWVN4/tDmDwVuGlG+haeFe/DMWeMKTTnrJ6smE/DTJ0Hs2rJG5EQ5evLooNUwJdsIK1nWWOTJfOvatq6vXRmBFcF9xh1W3cGMGD8ium4LzKgvXmGzgCo9OWvPmdLfrryTz8bWvTtvmi/Q3Fz+5OVm3I/jyuIVSckMQoENrX23b+lLFJQU5t9Ks/cEbhuxwmjAZQ3Pk5ZhVA5ixRvn5f7doJURSYNcb6v1bA67UAO7FMEglp6lFXYipxtG1VSmPczOmNq1dEc/tcxtVyytLHWD1dqPewSrRCh9LQY3LQ/fLddeadGVzD1P3GMunZhPIOJiwbJRLbh9qW1yoSqz1YZshjHhkbUJZgnz1FTXrI3M7Sv/7yylQiOkSyE7y0oX9tuYZ366KfRZ/A/uxhUDWSgoaa7ypvU9Fp1ylIKUdmiVbOkbLc095X5aG4/f9Hhz+YuXm3KUGFwhKanx3BsrJfE/Wbw+nVboZF6Z/EohUy61X6USrkvQF1uLbt8y53H/pODojkeXRROhtRHLdkixEVoDad8D7z1gWi3aynz/8/fBwnoxRS517aWiVrU3BxhEcqs1RkuAOTx2omGyuqdt3B15Trv4m7EChMiFfPZKgV+HwjfZZqUNaguYiSvsmlh3qEibrIjMiTtBq07ddGKAsjpr080DTvuxgOGiKqnPlfLDVAMypjHmypBFzEXoe08f9rR5/JnHTZfOXTJ5Rs7vcr45ZP1DSjYwWQf2Ps5ZxZ+HjHOMl0cI4wgSzkN25gaZh5hmBVkxKj7oV5BVzylmffTBSVnWC31C2zVLSbnWCetEyDgzCqmZ/VwjY62xbhxLXmjrqxxFRKr6hgjCfEgsGTFMWXMFixbyhvgRFJ3Uc7WbGSTQiAj9viWANLUqMrKQOLYUMNdO3epUc/4z59fxVJm6RALuJ+7HL2d8melCc5U3l+zM34uEp0T6Tdtz6gM1ZWQOC2Pvh3qrJk821ZgiIilyTO4CXfhbd+TmpBCfvUt4JrElQBPEoRLj0n6tGKDf9tCmLjwZedwxkv9eaf0FN9sj1HayPwhKxZSvLSoNbO5SCdmFv+FhqeLUVY6JlT45c+szVYuOW7eFtE6tvXyfTZB2CqU0SlTWCUdSSmn31MWm2t/ufNIgpy7XXSEbmE/ip1lPLBPs6Hi5dbcIYB62zl1v3dUcuv6hlhtB2uNbWWLZZiEwZ1K4PVjT9E+ewm8oXig7ISWg2nxALugfrRRDOeAaWCfKVZ6otNu8aXNb50vM/SkFI4tiyd57IPOzIjdDHEC0Y6nmS9mid76r1N9ws5Ra+vaxDx8rYc4GrD2UcpSPLMp6DXusuYeZ+cvMucrQnNAP4uj89aiB+2E114Jbsej4h1Zxm/Lz3czvit7DpV5f9WkavJvmxntvND3fKd44xSwHUkzA4mOrxBog10DAooU/Nv4xO7lTfMIhd02WiynlBB4DmzYbprhjxLUTMylWw8IhEEZP+sV1sQhtc96YGref85hj/TZZCunHTi16LnHfyRiHGICBy1YqYx6KLdl5tZ3NQx88VGj/oJ0GmZaTWppu3bpZax/fg2raj3ty3RUpfmbag9m4HPfdedueZz767iOruPj38es0pcw5of1PYbL1QX8RtBobW9csz/xwhXVWWyuZz/MbWfFaWdZdNtzLX7i8hD1VXAY+3L7MAorEGU+ekdmX8CddNeqqaKqxr4i4sWKgUqZUYaF23ZivffaazcSrJhrN+c89lMjzhFiNkXcQtrl09yJbOMiimKPQjf18rJn90Wxz/D7H1xsDa4O3jMDHH4pQJgc/RbAwmDFrgBvER066ZtaW6qHa5iBaLpPHX+ShHHhpfzCVd84pnUUpCkUeunM5ZfqmQYq83fj6jUnfF3OhxOnkDVbls9ybfqHIVeG7jYytphmrqQFCqXJcrxwuGmmTX1SN+56y5Slm2HvDrJWDqqTac7qvCVupjDlzR6utQ9VlAe0nNQ9a5yw/OLwsZDSkBry5hQk5NdOe1LnS74k6vgYNKMOUTUg9RZJGKdYt7bSdFV9Bfy250JLRe7i1Y/wih7eOuTVoMbSxIhluUbEk1jdiFlPmbkrG0wHrHGC++uGrouB21r9fAVcsjtKXKUGgP/76o21HyCIoiBWV054Pd4gbtE77qNVTriLipp279Wgq4fwIgTbevvft1grvxg/K4cBfC7TtnanvmGOGH1NyHdrnrxPmxBKvLWF6dkpPu68mGmRqr4tWzVqp6V4MdoqAlA0uZPqVnHrMy3yuyypdgimmsTiCUMqVlgMv7ddM2Ew4qvFyenGLq+GfzJva+eiHj5Zs5gim1IXNRsSmhqWC3+UwaFrz+KOnFVFTi8ncTb1NrazspsqVm/LJNdos0cYM3XOoTcGF3ZIqqec8fY41GcumngWeR6rhivKXcm8U7KxqqijEWAfyCmEh69r/rv2rkkqIGXrazGm5rnXe0+fZ3xodN66dLGMv7r/Y/XBx0X/irwdiTSOGSoONGdn+wuh16Tvq21Sj3yqFahGZk0LMST8rVZRYEGLjfIpxijzSby5NgbDNSpossiZrbeHmZG6csvkpZqsltqpan8FP5LdPm8ux0hF+2jkQPpmsdUfmS6UVjbeZIy8l/k2UKlfeibLpu6gEmmuL16jlU188Iw3eMgIfP6ZtTpRu7AOls7Mg1gUwdfpU9SQuhER++qGbwiabZFaQF5u/H+WMZUIjPgtVDO27RV9bsyF2chE3ESyv0if4NSFncnHBMxdUFOQJeZkLIuhTffQubh5zc8lr0m6xvGjZM0Le5J8m3LoiqWZljXgp9hzlnMRS/O48Mwo2CtW8dBfEXEx5r3P1K1cXTNAuX8xWK29lnp74dMl38NvDjunOWck2w7WQ0obVll7NvPfVe8HYC99lRiXUUAq3G7hN2Qh/nbgg7iCWfaSdVudlrIl7aHLJ0/gdCk4+aN2DLJGiJq9YK8SaXDnqyqIAYRRYDkccOFou2rJIZoXmDt+/4PkLCp9Zu8Xa5q0v3qroOW08yrsPFFUjlzH2ExFAyHIIV02Pjj0KjKhiGYYHJhQLhrJAMDfVdGNoFOiP07Y6zcprLJpSsM/PCuMzlNzIa+X2OVKk+On8RIOPGSG1F//6a5+/ZsmLEIAIFYp8UVsjBAZ+QLcBdqNzg4y06paaf11LL8vyw/v+2NB1oYMGmh/04xM+LlGO3FgJX2mSNDsWQbUrrbqxLaIUhczgPTboYd6c+qZ54dMXct0jFnypudX8WI083ALyfVCNDYRrUVfDLzfvBjnD98Fp1OV0IWaEdHWo4edX/ALz7qpuV9mTWCXXYE2BpRde2rRdsm0wtkNLPywnhsRFORt/1jpPTY9lc9t59Z3N+K/HmycmPGGVAJ+XaF7BT+dPTXUF1ag4zPNREgH5m7rOKr2f9lxYMSURweUB8t3HElPDWPlp01q1czdeLM8cbTSnnXwf66qvDIdkDcoi1r9y+iAr7qcc1GJGKsymwRcagkwCX/BaDXt2IzupyfJAew1RQWvpZXIaD3FdSAqXfCd0XTklapMNrRposRLrtVyvJOWx/wv9rTKSJxre76fQpGcD7ftwX3uSdE8WGg5a/yC7+SAc8PsTlBXLtin0x+xZNngLKwwmfAD3Qii+h+u58TliVv7riL9mPnveTcP/vNZfnHx8in43hoH2QXgkf7ds3tIMnzS8xLKDQDtqo6PMta/WBUVXG8w7avxUsnFyjXHfjCsw7DIfoNP2LQ2h9MNy5qiLvO3eaZmdzBndzzBbtKmrQZKVpUPbKGDogz6jCGcsYHReKSRyXUnnF46gmKtBXJmsx5i8SgX3obQFsRcp6ywFfTbuY9ZZbh1VOQ4pWO7BUABflA/iYkJjRT8cvM7BZuibQ4sOpZJVlIdtefYciw1xLjAta24VDTFFRBQ/y4OVuM/MLzT4mBEqFYoiAvjNiYBsCM3fJxVeQxOBwX18/ONWmxZ/qUYFHSq9LoWuIMzx4QvhULwIn5FS2j6e/fhZNcUSAROitZaJieBJxcHrHmxP9fycuGn4tIMQcvuejSj0TIBFTfAliz2PcO73eD/LYMh4YPGKCTw/PkeLTWCT9NtZzmbh1lixhQydGiCiGPk+XL/AYqjgoluMjzk1uPvgEorwVDD3qU4bggjzWDVe7icxCaFSDJj4/fo6nPS0WjQpFOipoD15Y4Qe+vIhs9UNWxXiIWJxRsJDQsyCj01X3DTKCTKv3TRurBUbFFlPWa5AWY/l1K/S0P/5/vag5NLdV4KBLw+0gZuxOZA1p0LxHwTox/oHt7FYlklccK2s2r4Sw2wz21w4slQRKRccyJChtAkWZw31xTXS4JURLZsmlLe+fsv1gxVeXQwePbgwgfmNoMHnrNUqufjZiwvBTwIWxeBdBpcUBPNr2pzxeHHqG5NffJ1s8hq+mPGFDdjywfVxUcUUAUsMlCjgWZBkDvEsCOEhaw2xSkmWoKFftBiYrMBTt3BcbFNJEex838+6IXWO+BMpBR+jgNfaFWoLzyrVi7Vifq5i5BYSTIWvqCCEeA7YbUOVgt32igJBXZQRH45QP+8Kc7+Qnf+8BBZzAg4p3BoJn7WAOf0USnF3y6pL+q8G2ubXiyIQsZx6VRIPIcXYQsoQ7SdrSJszuB6jFpU5KcU+Kg3qDJEeEmgdgrZxh2pISWmAlD6VWj5uRW8U4ErqBrluLu05cLW49Y18hORMqnIo813Wa0xuxWDpCqpU2NUNMIaYz4fsIfXBNdLg3TSSTZOysRAUxMaa12TKZ+96uzSojXtKfIRrIpX4CQRqEfHVnNMTnz11y1NL6sVwH1wtQpSmCQa32q3ANSVqrK6cWGIpcKH+gCxu5SVWNp2W72QDhem7Vou3yqzPESr+Fws8laqhuCxQHCqp0cDp3vWdu7E1PIPPIZKFrGeNucJEGQzF+ORFSq0izLhSFVVM1yGSNj/wETBnV158ZfPW1LdKyN9cE/9+a++XTJdNPxEACTOnz8jq9w1ro6SIpBJs6rq3ANe9eIeLTd9HysvqwqqAksXmJqnyoljTFtqUV3bQ3j6d+pirXrqq5D3meyVB5Pb7Iy/InMtafSEX/E2clctlIcDaSrwEhyOsHzG+Ftc9LJmAlVqFxNXhP4/rOgkhizQyBa5lObS+ybDa9dZdg/fhM3YOBPhU8raHuRmSATyvL2/nFxq8ZUSyaVK0d0kZJco8L1JiG9hA/cq1TGIEgF+iXDP3Ak41t795uzrJmNDaBIRtUjY2Me3bk2UjY08qUoo7lM4ZKh0uvmgCKUd8OcJq5DxHMHBKGQOJgRFoVUMFmDO5B89w/wH3mxRoVgA5VWs8JHCHVDvmwneF+VVZhQ/EbQftctNPXWsJrscnJzxZYkFJYcZlbAjKJk6GH0kdDDGd/jLrl5IAW+YurjDmoj8veCYsBCG3hmQ1hNrmloXnXtoYkUYdErRudWqxGklGBNctRxFx5+q5T59rr6tZUHn/wHUPzLyOLdDZvlvdxmVmBSvUbr/q9najL+fUDFkYylhWOj+BtUJNkFVKAQ6MUEVorGWuyxDlRdZ7SHZUyz1VFHxqGlvLYEiRd9cTz6q5Hd05yu/tVtkueG+hWZAUcd/di1I05fvirEK5h3wGNx58KvIc266ybdmWEqlSHJIBvrydn2jwygg4YoMjzGmdTyt5XVskLK7t2m6X20SayivhB5WGAmBDCxViLVIlfVBfZ+I3dVk2mq/fhwQRavd0zdCUDseEH4sV4DqDPh5knv/k+eAmgVkWwar1kwR9ZW2mjI2U/aYeBqZ47V4+jt7oaBsLRHyLSzceChCuNnwfvKYMaqdI+DZ85ZVg7KPePsrsMHSHwmux59H6x/cXE2MUmm8oZ6L0+OOjzRdRUDW3Br/ZpHh+xiMGWR+pFPOS6SYuFemXFAXNpuInikosPbhPSfXXuCt2XWPXJIbN4R8ML+lHbc5wuieg0sUWK21R1Kf87YJ4pyt3urJovtHf2gZ3zjPn2HGKQTZwsp9CnEdkJzJWRZYVp3vmF/cKfSsEk/4zYP2T9UR82dHDjrapuL67XOaouHj2WqvYBS9gzpDtxuFJ1ihwv6sFCzc2ja11ks9gNXnuk+eKrku2FSm85cRG4WKOudXqszZNTRmZMxE1SwMnfm1xxQL1oJv2YbMC1tq77BOzFoFNO3C7pAISLi14ismZwuoqYNFgSWGzRLjD+SCLLEsI8PmQRr9mizXtiVVlTZyz4aVsPKQGEqRKLA5cCNDsQ/9NQC339q/P30NeHWKzn9x4HJBKfMYpE3cF9yJ1Ohag6YPPwc7q31tTBrXYpCJrybCeNhjbDUh0A2DFvRUDc963dGgxRlpMS0hpJotHFBG/bRLj4fruub8ld2oTrxwq1VpTT4mpir4Lrs3m88+uxeud+7ZbqJ36HXgksAxpc1nbsO195syXmDVAvif1RcRq5ROPuUo/v/+04Z/s3JQ5eue+dxZ93iU99OetWGxdhdO1xLnkYWy6KEauIsRmTDA//YESKmtTU1pTx1EOLwO7DTR5oW22BPvTLolXESDbeH2phZayqa7MUawquIGBWIq6r9Fd3dwJEJXaSu68c78bOvBM/3m6/cx7X5Zy4QAsb3JoyWNBIi6N+4YIJo/b5Lh6q01TU0aMCRJEYQb1T24SRMpE4UTtCghM/A8c+IANvJLJaVMqNzzK/Oed/xRdm9f5nKvdar5NThW4NjQl4uY9b05ewASuas+osXrGNmHaxMbtbpb81troP+9mK26mCjzJGkHZCG06EPHENkX/esTiIGTc7JuYRcU9vcipWXObaIAD4PjNjrf3kkJ7oQwD6Vf3FIxbwb13igVDA9cKBcDG3FsCXANY/XxLR3SDnEMSF5o3tgLpK6U1ady2uUG27gn1yYlPRp9XDgYpzMH+/VOYdiW+BIWJOCf/eju12Cl6T60NxOL4Qa7IEThaYv3M5zkNi+uGg0VorrhKH79RUoHM0RBCmTFco8f9PYoUD377SgW/CZCUQG9++4zM/FtzdcZcB269GrFgEtuDEqC5+eBySaH6BzyDy96sPbsoENAJhOSEdTs5axtlacbPM6IB6aEDQmPHldl55c5quyhCiPs2lDWZpYgRo6b13bGdjjX1hZoyYox5ZfIrJa9J6q2bHmmLyj12qp2MmM5xhzDZDlrnIOsHxcTPBHWDRPktn3OBQEHZEe3WTxcuMMF+PV5dKFg6AIpOCtCkY5kyLvxN2O0TlDGtKnGWIO3duneBMVMTeCzStz5/K2g+DAUkxoCClHL6DZ2agTv+mivPFRwuQiZrNjdxQWiuF+6NgCrHbK2lp8o89l0RvM4pWU7MWHf+O+6/uZUinkHM+FoKNDEaoWv48497aifUkC9dov7dMdIydGL3Ds11ybCxga5PnavOvas+KQ0qTQHtRZaIpQ75ECOLk0OQG2zqzpWsA4lk7rkuuxAw4Wt4eNxcpk+5v6ZUSIwIymWIxdpaSXPO741bbWxO2/q0QhxTLJVbI5WT94XqH8BZlFWZPBT0qckJrCciy0MlE/hbKB20A0Ijz5UJH4jvbuZvXo8Ve0TGWAttIH1Z4mHc9/u07lNvVhHQ4LNpCPY7/cnTgwuY7AmsByz6EBfALW/eYr6Z+Y05dL1DS4R+LEJaBLFvkmejwFfIpB37xVj1+3CZpFL+uidIl70zlsLlkmtBQy+CMGXx+oti4+U3Nm+MfKNI4GnZMH7mhYuyLAVzyHtiUfHa6+6JHcjv7W4sDVTzCaN8FluBW7obIR0jlOL0rGaCRLK+eA42z19//dX0Gt6rSBnWlEfmN/dBScVq5hYcE0HLyTYr08yemof1KJDE+aRsQKP4d+efdcHNIaIL9csxnY4p1ENxCd8EQlDHBhOCVoIB+JTyfgEyLQarHDBGrEMJ5M5K58W9td2q21lLJCfg0MbvZ8CFMlVCxTZd8N4uq+1SUuVZrqGlnPqv41a27LiBswPf4dlSM6nAFTteob7ulrCIyUNRCmSt4k7ysxFDEKUxZOVw+9OV5dpcliBsrOihrLzZnisTRZv5D0cUFhHWQMw1TnuZM5QmkGwu/z7IKJc5/LxtzjNrfr2mqU80eGVE4xkRuJtvVooXrKBuBdUY3NoHoY2CHHCZKBpTJ6bv1A1a4kI09s4Y3E24HGUAdwUnGWj33zBzlZFK6r7koV13T7+cAjRF6thNjrXZClo6rYtQvIpPGOWz2LpjyuJfuvnSZrGmiwXbzGaC0NGwyQqbmBc/fTGoVDG29LXfPiGS809gCOaYUiQbXQrDJsUKb9rzpiLFALDxQmRF+rJsllhLSNGFoZhNNmtjZjxgoRTlIFTBIkYqxX3v2/8+e6gIpadq6yGUJq+Bw8iNb4QrVktfX/HCFUkWJ5SgkItLINZbd13beiXKmGmbp9aH7ZbSY2F8OUSfskn6lXOxmBDPxoFJA4rIkRseaa59JY0NeNultrUWDbeNbnp3KHsptlZTFRHAfNUOUL6cyONeDR3qZgcORlIcD2TVMIPTyqewF3cd8gllxo/Z6fdkv0K17/pCg3fTaFV7NVQjzYzFjKXAresQSiUMBXexAAg+yqMc8B1OjG4FUk0gaWmi5cYvuPEoXG/k1yPNnW/XZbq4JGKX7XBZ7utKRDs/mhlUPuOefnGhaRUzB740MLO6b1YQpwDhH3Mx2GDOYUeZhZsuHBX2xMdogBwrNA8lJY8fjcjK9z1npU4K8RsbHfEMWYCYzA9yRNFgjtMnCNV919rXZkwRrCy+d/z1WYqIjIcfsyCpvTJnY3NVFHz8/nlM0alBzLRzs5U2y/wcqb+hNGkXrmUrBskMceNuUEyu2ukqNQYtlikh43XFqCuCwc2uO4s+hfvCB2PNZqhZlCyp1uirS4Jd3UBkXoO8EPfhs4c/a45rc1zh+9ocyBqnSrhCULgg6dNckK5ljzmY172a8tnGihuY+4RAvxGfqD0v48W4aMqwVPuuT9QK5Q0fbv7z63/MTWOKI9LnBaTwWazAFJNPO4W6RZxi369G4Tj3MynFvzRIMS1OaT4BmQgHfh+4zoHWzZUCPg+XgRBxpRYgFISKVBFrQL9qFqO8z68VyvIB+6nmkqqUYIn4jxYLtTDtrmpXsfJM7AWnVyx3bJ4p16Mf2eyzSNVA1vXEgkKgXWisJV03DyGdzMss6wCKDUIf683oyaPtaT9mxcM/z6alFaf0nytmZcp6P6vAnWtpcvvHLeingUDOLBesEMppdVLKgRB+0dewP2suOLeY6ZQfppTMAXc83SKS1VhTWp8xN9w2+oVF89yrV8de1joUmleNvMrRWUVL2SNwzaD8x+DOi6Jn7XC1OXT3Q82CCy5oqolaobwcMSO3vJO+GVYi5Pkuvs2Pv/tYXcxcn3QwcdGEijixAMoVBprvWCOOcj9jXRwZrKmkND/0wUNFgg9oTKjuqS9VERF8N/O7Qrs114lWgFAQYzj1XQtiBk4xqfv3J5Je2CY1LNRkIdXXXqkCwWkTAj8C0eB1KYcTRQQgp9c8Pn3J/EohVcujcAqCWSOOTxxCQuaqKA7axp7lqlDjfeYoOpjJeUY/6NA9PWOti7kfQ3EWrvsqK+spFK9EcU9XoXALd2rKuUBiWLJkHm2ydVKUeSXPlEdG0kci61JYhUMnemQqbhpJE5fYH2KiXBbcPOA5/rXTv0rYSH05oaUop4Dn7bd1P/sTi3eZ7chKlAwOBnA7aXKMOBHmQxZshtBGRxcUIan23WJSC1OfaPBumljMiI/YZEs1zzHpQq4Zrs9pLGQOlAXABh8DbeH0HYKfXqYJejclNMaaKhBFxC0OxXXL2WBDRcskzU5qK4Rq7IRM0TFTq2YGlsyOPOCabExCJKXNi35P9DN7rrlnVQqCuaD/+zzUx2y42Ibmpt3Lt/SVM2bwSWBFqMaJ2VU487hLmLO4BsX9h2IfyyBzXTz8QMylxvvMUXSEZMzP4CB1nDRLqY0jmTIapCCimy6O8ko2Humq/vVD8JUE4gE0hSKmnAtC6zRUu0brU0k7Ds0dnlNbC1p2iuYuDrEAc01kqrhtsMRKfAVWgnLnI89BhpNPHChtoX2phHuDug0qqrNjM7V2uaYwJihSp21VmqkXCoDF/YWC5WfKsP5S1+5CCyxUSMFGVnVdtasZM21MrrpX1UaDd9Ncfufl5tT3Tw2eIlPNypVaTQq8Bj3q6mb45sAsV4N7DYQhzIExV5Br3tVM4ExwJmvqKc2FmE5Bltla+y4U6DElgE1eO0n4ZlU/0E3A65xGaJdr4i7XJeWb6wncFSDItJodQHhmYllE5eCIFY4wLVdpaS587kIzvyAm9+63ds/8rMQHhLI/NFcKY0OK7bWv1gU9hr7H3HdrOBGXAPeFm0GmZTylrF8Et80SISj8mQvNaY+HWZu1a7n3D61veVayizClc9oNpX+mgD4g5RRoayE270n39oNT5XVirWT8QiXufXfbrWNuzXQF4bqQ4Hzafv4255svPvzCNF2pqTn/2fOrJns0V0XWNX23jFzHd0ED/zUsZn7ygO9Sm51z/3CtiIA5c8DdB5TMFb89LlCEWy7asmjNlFv3qtL9u0ErIwiU0x8/PToJdmi3g3lk3CPR6+Tx8/rQJjMTN1Y7QVtk7qSTCQU0H6r7OUldHvTyIBtgKiCNkp+Y4hMDJ1MyabSYEQ1urAenzFAOvShSmjkSJYV7glhhudB7WYpelhCjbZxwRcGTuAM/sr3w+UaNbaBhjGPi94RQLAwF8SgU6SoEIpgJztPG0t34GS9/DpEaSWaSm6qORc6PGRGl2k/XLUfpRMlE2SQYPDSmIWgFBTVoc/OZj54pyf7QMlu0WCXaDINorMiipuih1CEXtPXANbDsSeXq0EbqP3PK+qoGkANYG6p5L67JVulv9i5kDmoKl6vQSH+npIw3zthbmI9rLrNmUdyKHycE8hQOTYmrmhf7d4N10xCwxcnGVwR8E+Sj4x7NNA8f1fGosgsXXbLDJSpvQ4gvQfzSfoE3+a4f8yGkatI+9zQpqcssWlcRAZwmyyXfElp2yYUfd+w4c/SKYTIqKWAmfm3MjSHQ9tc/e119j1MkeOC9B0oKy9Ef9OmgUYPU9xAQGoGUXxSLvo+RZPlZH7FNy03dLhdd23atWnlxoLWHv8mEyfqepojQL8xxjfIdZQNyOP9+bgaBuCX9PsRt8vWPXxeNI9+JkXDJRqCl06eAWBROs3kVEfogRRHRYrdwv9z4up4u7Lp6WD+u+4c+JbaAFNsYWZcQzbnEjCgiZJ+FXGN87q537sqMlYATw33mWBZINYHVFG4kre3lrDVxBUFpH5o3wg3F3NLgur2lv1Pue91ucaK6y567rDRuZXad8iRrjR8Oeqnw3fjzCw3SMhKyLpQT9SynYSwAlfBm+EixkOBq+HLGl2bS95NshdRQlki5rge+n8pSGALC8f1j3rekZ2OXGmtOfaKYB8LV5CVivNkCzWx9jxBCJzHae8NrN+TiENDMw27b3VO8a1IXM7tGkpUr+2aOK+Gm128qy7pGu6lRkxduRpN7ktKsC+I+DLnsQqe3rAwOzeLhW+7gKAm57FJM5DETewg8zxlbn6EqV1kkcH7bsvrAD5bOE6NksycmjSoQbWnrIrZWmLOaHCzpswSeGQ2udaualpFquMTn9/0qcXuXA7/vU7Kl6tsy0iCzaWIBW5oJnk1KoulhF5RofZ+SWjYtPnPKiFMqqvAqwZohxkRem/jtxCBhlNQMyZsN4gf6MaHpEzebRvPF77HmHmp+O+/z+lI/LWVPb00WaDLXPznH7+9q9SnCOOSPx6JSjiICtA0dX7hsInlIstTxCGxivEY/stnf8fYdSQXyXOTJeHEVC0mjRJmi5ABjjGUqVrjLZ/AVRtkrX7zS3DP2npJ74YLyN2HZfLleLNPK3nf2LBu0GNoMYt/VuCBSFBFXAT33mXNLlLLUsdHS0P2YjdS00NB7uG9cwr6UPrLP0aiuRMA1L2fXDGL8iClIiQXKCiTXstlSUuH969qyHI4MJgUdGV0O3PilECpVRCy3ypwA09hzNqqSkuX3fYwM0AfjEWPmnpdokMqItijARV0vqvOveicBiaZHW2RzxvQ58qORNjfeLzyFoWn/dfa3P5BXSYpnORPNTVvzA8+yNF3uRcBYCsGSD7cgIMDNw/PQFiAC9twu51qhxSIjRS/0fCc9dpJ9/l9X+bVwrVi8QDntZQGFKlyWCyjwe23cK2lhupusdmKnJg3vvTP1nZIYEaGAjykiheDMOUqumOZjyhsBsjN/nVmYg9JPMmctU6cXS8AmHEp/Zu77ViLmoaaIgGUWXqbo71TLhAv6kYrLN4+52eQB/cNJVJ41szqvx2sCNOUri8dEy2LR4kCkdHxKWujWbbY2T018quR1Lbg0Bdwz5mqSekYC998amN+Hrn9oSaCwpsBrJSlAilWZvhMrk8gQ2XSpvF3OoYs+IIUXGcvhLotPppy4jvsPuN/ssvouVkaE0rpP3epU89OvP+XO3vOh9X3WAanIoli+x7hiNEg3DXAJciRgCz8pwO8XCqpzSZ1cwYIFQmpw+KRhLBptE8qCRuokdXJS/NahRQKhFYv5tjdvU0/WfkS7PAsuG05jsHmKkNdM7SnZQiCPSyMlSI72xYpHVcPcqSFrkxWyu1jm0tC9hgYVs1AWBoi5G6XtWuZGqB1CVOdvGHJvlwwsNg9dgj/5TrkmaqqwhoqfpY5d1lwj+JbYLy3TxCe5cuUGaZsrLLGCajmAhE7qiOQZ798CXHmDshlTfFw5GCIOdK1CofkoGW4UgZNaWPRx16W7msO2Psx0bts5amWqxE3uPsOdb91pY95SQTXhM548Q51b7tr328l7+6y1j32OC5wiiDHELEGhIOlYtqRwsWhyYH67aRqsMgLGfzne3PLQLeagnQ4ybZdpW5RW50dNh3x+odQpf0C1OJWYiTA1pTgLWk0SgpmkOqfGYOqbTXltr7X2Ksm2wTKSNx6F+xNoh+JHMGAWmZpg2AHDSsjg3AwHweH3Hl62q8ZHKMXU35BTNlk35dcVSK5bIA+bbFbqsJviqKV0xthoNQVGU7hi1j6qrGJVKped0r3HgG4DcivyktLqc8jE4h9S0xrpm7GfjzUTX51oGStHfjJS7UvGvFv7bup7HAjyutjKRWrfV8pWqm1gvitK1r4P33okbvE2i7Wx8WbrbbWemfDdBMuG66bDCiupq+Sc9MhJ5uXJL5f9DCBPTGFW3Jd/oOHQhOxzg4DzulhjTLQaNJkTyyBMOYSlopZNkwAGbt3F1i3SWhlkoqZDpDL+5PG5DkIRyVghtABVlyCJ12DGIzCNTagaiogfYQ+kPPUZj59RxE5oAwaVku8sMD/bhg1/2LvDcp90eSbcS9v9eztblyR0qvb/nvL9FCugfGBWdYl6btj9Bqu4ZEXNh94PldwGbpYMFhjJlknpA1wlbrlxLbuEjdAqg3MED9k5bsl0jXgJJebjEz621ixpO9+lCifWOq2ORyyzgTnu1zAKxVvE5iebgZu1lDqXt1hpi6I+YI10X6N77iwI5r3fb7bM+wl1Zd41UjHaSpvJxoqB6+KqbdG0he2bqdOnqu1jzEMZWgTEzy+k9n0l8gZ5h0XBJyrzXVGsfTbirCwiIZmjr0d8OcK0H9C+pJaRxJihOKCAyPwtRxGpJItE4r6ySPYAaxCZQXxYXtk5a07sFiCw282mwoUYs2RoMgdoGVNZNYzmFRq0MuJCpfb1UqRSi2b5A4pfXdt4qaDoBqDyPkKK36Q8VpqyKfErBTbQRsWsjSgURW2abSwddargnzJ9StltfHyCXtETU+OLPV4suq4E87ZZsk1UgMgGPePnGVHBGjsB3rbXbSULVk4zeTfkUDsBgoP5gdWiiPVQuj4yBH6xMNwqg3YZZC0BIw4aYQ5pdYg57YnTior2+SmdofRprE++8lJuscQ8m9vZW59t3RrPHvmsVRgYA36LooZSksJYi2CGg8S1lrlzA2ChYny1Io20GZcLFrYsyCZpDy+BA4kE/rptd4O2/5cg6fwyb0IMpcg8t6iilmot64X3B348MNpfrlKSN9BWk9nlMEfTXhRPLCQ+M7FPH1+J9enlSS8XFZ9ElqGkEMvkM8XKPYXN1i2mmIeVen6hQQaw+rVpnpzwpPn6p7mcBQIG+c3P3yxi6nQDsELwo/g1mmZZQNo9pd6Em7FSDriHlJ9OKbHNvQnM7dmxZ5IJmXo0BLeFAmnph94b9zZXvZRd9RXwzPg8Q/T0474cV0r2NKe6rG8O1oJIB3YbaJZeeOmgr56NDK4S2ajFJYNpONWdFANxQ/SXFF9zWQ/9Im8uV4zragGxOkKwCt84+cbMLIlQELd23dBn8yIUw4Ti8Ldt/1b4WwShBFC72WqhOh7MRa6jMZr6c0NM+1id/jrir+pzoagf0+mYkgB1gWySsTnhBv5y8MgbM1MfKayyuZULmTdwwHAAC30GKwrzMZQNKH3X/7n+88Wy4wbTYunKO9+lNtNNbxSXYUB+485mTqYo9Y0CYy4B1H5/adxSoWytkIuMtdWlTZeSkIX5jQatjFz/2vWm19u9zOy3w5NYuAZkMKX2BZu2FuSEZeHSHS4tEqihRXLXW3dlpnwKe6SbUpyHol6sM6kbSp7ALXyX9EfIwvHLrF+CBbg0QNJEv8HAqrX19CdOV60/fN63aglZmRaEGezzOSW25ftyrWptHKG4B9rC2GpF3cjIkiwb4d0InSLpO36H2uFa63zFOlRUTrK53AJ05YIAUU3JpZaPgPEJBYPTZhQIgu58Bfi/H/zXDN5lsBq8588NDgFcn+vyEwrAfvbjZ4PKyPOf1AVbhuCfMFPq9gilPmO45EJLmofef6gQV8D82nrlrc3Ij0eWnZ3n3od6Ov5YcL3ztj3P1k4KBYsjh24ZEy9uSftQ3suVM65i0P/F/mZeg75EzhI4m5cjiM/G3Pju2gy5RuUwskqk0F2I1M+/17Wjr7XrDGguMqzjvtVQC1moDzRYZQQh1fuh3rm0bhGAwm6oBYfu1WGvou/FlICsCq8ueyQ/bjobG3DWSYs2ExdCHAWTDEtLtYI7AW3h+TQrBOyLeU+CVLDMm/7JfVEMNffJrXvdatMr3dOyVCEOncjkOfIKeqLi4VPJoyz6c0Gj+HbTffnN36HUWxDy9WrmV5cbR6tGK8yTflAhnw0p4yFwrc1W2kxVRog9Ii5EKx2gnfg0BdgV+m62Reg0KtfFXUPqpWbeZw6XAy2rIeswQP9w8iUF1A/C3rHdjmbIrkPsv6VmDX1UbjYOcWrIElzCfnvICkGGoQT5uOWNW6xFLwuVlseQlGzcC/PDMsQ9Rk8abY556Jhc8gqXritftIOOuzZDrlGus8/a+0Sfl9e1ta8dnvmBMTnkImPs61PpCKEsh/+AAQPMKqusYhZaaCGz6aabmlGjRkU//80335hjjjnGtGrVyjRr1sysvvrqZvjw4aY+Ua4fPFQ50Q8OFf+dH5gYq/CaEkgklgAmNptqVnwHQo14BxZKiFa6HMSCnBCW478ZH0x1k9/yb/pmSPc6YZuXh4J2wPei9R1ZKL6PVKoQV9tnLwFpKJek8jE2eeFaZOT0qrnxLHlcwMc7+fvJ6rU5cWtZIuJH9qvFynzVggr5LMIzT7wQz3bEfUcELUb4+0MWCj/eJhZ058fTcJIPtVMsPzN+mlHyHuOA5S+EzVeqK06WQv0uyhFzQpMDgOfGTdfvsX4lB4aHxz1sBr88uBBcj4KIm6NcoMyF5BLjfPc7d5sjNigdKwJDs5QD4cMpt8QB15cgTcYuD7RyHtpnNLBu8sodX7748Rf0LUU/BaGYQ/hNgBzsQvDXfpY8Uq8xe1a9UL3PE2Xk9ttvNyeeeKI5++yzzSuvvGLWX399s+OOO5rPP/9c/fxPP/1kunbtaiZMmGDuuusu8+6775prr73WrLjiiqY+oU0Mtw5JCiTIlTzzwt9KsKAWxe9uImJ+jgUSaZkcIZ+sZm4+9+lzyz5l0E+k8mpt09xQYlbWNgyCUwlOZMPmxw1UzKsguiReWt8BysITICd1TvIqO3kgpxcC97Rg29RrkBmDQNcyLuhXUWC1QFvGWoMf5KuVancj7ilGqLHpynWwYlSTFSCUlaYpvqGgOy2eBsUz1E635ojWnpjQpg3HtD6maPMQUq5QBhZtYVxj2TzwTWg4/5nzi55Ls1yAvTvsXZQ9529ubl8y3oxzSTvMLPPK5FdMXgjRHHEJfv0s+gZrchb4DpY3akiluni5rxwCCOJm/hKk7CoFkqWI/NGy9bBI5UlOEFJIP3to1aVWtX1gXSGNjHUJyuGUeRHLCFxJqTuW5/Ca2nYZf3/91zdy84xgCenUqZO56qq6oMRZs2aZ1q1bmz//+c/m1FNLKWcHDx5sLr74YjN27Fiz4IIL/qZ4Rq556RrTe3hvu/hcvoe8pDex+g8u6ZLwU7i1THz4/A4h3pM8CJUCT4XU3wFi0scyIwGVIUIdlID+L8xloD1h0xPMCVucEDQR5iVBO3fbc037ZdoXgotd4qSPvv2oKOhUAhfLYTisl0DCUGVghT/DJaO75617zAXPl25oZKrgE3cD2gDPFarkGuIyAP571Qh+DM29ozY6ynRZtUthnENrJU/tEylFEFOAYrwNBApj3YX/4uXP6k7wPh9MVh/mlTMpkLUnMgZKAbEEanVy8tQsSYEv81zWZhihs+5VjovTrdbtwsYfvXiFufS5SwtWRzZ7IHwzkkJPn2QROArvz+tTXp9LyuZUSNfWlj/u7AFZvB6fzOm3x8c/XqiJpo1diGMoBpQuCP5cWcAzDNppkGk5qaXp1q1b2fv0fCU9w8qx8MILWwvH7rvvXnj9sMMOs66Y++67r+Q7PNzSSy9tv8f7yy67rDnwwAPNKaecYpo00a0QM2fOtD/uw6DwfPHFF1VVRiZ8NcFc89A1Zv311jdbtplbYZLJQMpeJSdoJu4Hx9b5sAmUJT7FHXgxg2pshAL3e+WCUt8wKFa6mZIyCreC/yznb3O+mTJjirly1JWFRXPgOgeaW968pbAwt1tlO/PYhMcKAuGCbS+w5kYNXL/PQ32CQZUauObgbnW1ZXoN7xUVJnnqYGQpBvUFGQtw5LAjzU1jiiP4tTlwyfaXROc0ffPM4c+YTit0UseCcR2400A7b8k+22HoDiXX+PPGfzZXvXxV2XPNJQGkPdu13c48Ov7RIoWSce66atciFlr33ynrlr5otWgrc9C9B6nvu88aWqMoIyNGjLBWXxHedhP55Hnz5Q9fmmWa11Hha/eQ8dPkDPfebY3dzN1j7y4av3vfvTd5Dg7dY6hp0byFTZ+/6LmLCvFI/rp7adJLZqsbtqqaos2Y3bT7TdaFpQUSV0Om+utXCnGGDnbtrmpXEs9GFXEw7utxpt1S7ZLl/ombnmiWW3i5kmKfqXKFced+2pi/H3kGv51+Ta2/PPwXUymsstPhanPAzgfME2WkRYsW1VVGJk2aZN0rzz33nNl887k+05NPPtk89dRT5sUXXyz5zpprrmldNAcddJDp06eP+eCDD+zvv/zlL9bVo+Fvf/ub+fvf/17y+tChQ61SUw3AESCpeUzQPq37mK7LdFXfDyGruBXX3HCxDc1Rbxdr21YbX+sa8+q0V4NtIOXY/14WbI2IVoeahRovZL7+5Wuz8eIbm5mzZpozx51pKoG0F8TatPuyu5stltzCnPL+KZntPqzVYWaPlnuo7/Hsk2dONj/8+oO5YMIFVWWP3HKJLc1z3z5XsQA+esWjzWILLGbGTBtjHvnqkapbTkLPI2MB4dZ7098zJ7+ffao9p11dReeseaCtAxmLVs1a2XvmmZtcb5ultjFPff1UUKmU5+S5erfubdcL92vWuJn6bP6pU74vbQeDPh4UVWIvWu0is/SCSwefwZ2bvpxgfbVfuH1Rf8jnBnw8IPh82vjJ96S90gf0P2M7dvpYs+Yia5rVF1m96HNZcz1l7oTamxdu/4OQPL3+0+vNfVNLD6t5wLgsusCian9pGPn1SHPJxFJL6F/b/NVstdRWJfOb36E1YrMpV/tn0nrT4Pe9O5bMqT0CsjALtL/H2/msIzE5QUZNtTFjxgxrgKh3ZYRg1R9//NGMHz++YAm57LLLrOtm8uTJ9WIZCZ1I0E5BIWPl+8nqyYGJdfPuN5vmCzY3e925V1Dwcc0bd7tRPR1xejn43oOL2uCeLDhhhU5uKdaY2OkA9OnYxxYFHDF+hC1DHkLKiTjleX3ICSVkBq+GVaha8IU7z4mLiBTIctsX21Au6HKBWXqhpQtWCXd8qdNybKdjbb9Rr+Xkx7KFI9fbb639kk6m2ilNswy4VpOs+Qhe+PQFc9A9B5U88z373GMDFakM27FVR5u2C56Y+IQtfpYH7hrmNEkqZMwyYefYHDdt6DqhPmP8dl12V3PxXhebBRZYQF1jmrWH+DKxTki/LtJ0EUvUFzr9+qfk0HOlIHQ6zwuxpGFhYmx9WebOIywwW96QnZmUpWS5FiX6YeEFFzbTfwq7vGGNVmXv7kNtkLGldphjSRXL0elPnl7SLzJuG7XaKCr/Yjhk3UPMdd3nkpJd+sKlpt/j/eqUKs9angV/Pbrz2CpoG/U2A14Z8LuzjORK7eWCKBRTpkwpep2/l19+efU7ZNDwcK5LpkOHDuazzz6zbp+mTZuWfIeMG358cJ1qdBQ1DrR88IGvDCzidMAXqMUZ2ACvz1+p+2zkBMY1F1xgQTXdi/7QMiVYPOXGKPD9idMmFpHWhPpr4OiBSdckPVb8sR1adoi2LfS8GrjGwx8+bHp16hVMu/6tEET5J9tTtjylIkXEv6Z7bbdgY7c1uhVidIiOZ75d9uJl5vJRl9u5uU3btNoRZzxxhjl4/YNt8FyWz54xdOeQn2pNEOKZfzjT9OzU07YvFvcg8xFfeGge7nFneSfCWNu5H+0nHsIHa2/N5da07aH9/ab1M+c8c456Hc5poTFm/DjpD7t6mOV+iaVkEvMihSfZ7FosWmcV8Qtubt9+e/u6VggO8Ez8ECNUDrgPz54VKC5rib6CQVSrucLfP83+ybYnJE/pw8cnPh6Na5BgUEkZDxVedMeNe3Jdv//cYo703dZtt1ZpB9q3aG+m/DClyKVrs5meONXWDBryypCiFH2elXFj/WiyTZM9/mtws+yyxi6FmmBWfszpU67X56E+dj6GCgEKtArQshZFQeG7KcqIy5PCgbPFpBZV22NdpF4vVzguikPHjh3NY489VniNAFb+di0lLrbcckvrmuFzgvfee88qKZoiUl+ZNBqnAxkxkJhlfRZo2SMSJHfaVqeV1DxhUoaioWOun6wI6oEvFSsZ5VAb++lreT/vp7etu+y6wZROjcI4b1aNENKVm06YBwiQ1AqbKaB/qKVDABtFsEi7lOh2SbslxdSfmwTgkT4Nv4mLzq07B1NYmzRukjva3q0vA9hUScOV7IBYiq+wUhJYSobR/AgClnL3tJ1UWR8oe1L4j+BSXxFx+yAltVS4X4K1jjDPz1FE3LHzs354jYBv6raE6gkJQnwVqfV6QpmEVCCmzhEZJ1DlEwgLRxHzMkY7EJKntJPnjJUAIKgT5VvSywkw9dON+ZvN0qdV92W133dkfF3U9aKS0hLw6Zz7lJ5dCA+Ovd5GR5eUzyC13a31RbtQzrXrlGQYzmHWpl2Q+mnK27Wjr42Of+i5far3lLIlZEdK5hFjkGqVmZfInRtEWi+puf/+97/NO++8Y3r37m2mT59ujjii7mEOPfRQc9pppxU+z/tfffWVOe6446wS8uCDD5rzzz/f8o7UF7TUQK1AHBMEs7FblCj0WSafmwMumjET8LxnzisEc3IKcAuj5U0lzsozxzTpnpxCrH9Z0EiyYoqN+3lJEZX0tjFTxwSfx02BLrfNkFZJOqErKOaVclLNTRUhxfOO+2qcFZK+EArV7hDhBtEalWHlWWHo1FIXSWHt+0jfaFvcFFkUCMjIQoLWFYKhebzpipsWnqlcgq68EI6KkEIryl4oxdvtA02Z0cBY9N2ib0m/xwpPhsbTLQTHb5TBQS8NKloj5azp7qt3LzBvanwYWIA5ubOBM2ZYu/jNPERJsBwpgSKS2hzgeSCSi5G89ejYo0jBkMKPUpsIJf3i7S42F652YVEwcaiWjcsfJH2ncQrxNwpiCMxvjRCOezB/JP2ddmIl1BSxkDLANS99/lL1/X88/Y+S8XflY6hMhp+Cru1v8DiRUQfvCenBlDrQatX8rlJ7AWm9xHzgatlggw3MlVdeaVN+wTbbbGMJ0W644YbC559//nlzwgknmNdee83GnBx55JHRbJr5ldo7/svxBT5+TElquuKcTAq3pgWIpeyF6me4n5MJgOJAldBznj4nKSCQ1DKK6CF0Sf3iexoD5PGbHZ+ZqhZyEyB8ND+slqooNV8QZFlpjSH4aW0Im6yNs6jdc9hBERSSOk0dmLxl5/PCNXOKqZlUyjyl4em/Ad0GmGMfOrZkPjEW5RC0+XEKsRRWcPpWp5uu7braMWczSuVicceNeZyXcbfacNdWLK2Wk6mW4u0yp4bShDWTvJv6ztr/csaXZpmFlylYFf12lJvVhbIdK/seAxuRT20vqa9idQulpLrzUKtxIvQDbIq4BLPkjZtOG3I9+KmyZFGxX4TmZjlu2ryBwLQbXhY/xZz2S1kFV5mN1TCDS+ia0dckZQvesfcdtiQDss1fY7EUdD+2xGf2xTpC3RyUnFUWX8W8MfKN309qb31hXikjwhUgA+BOKk2IuwOvTUBZXFnCQoR4XupzXzBRfAsCNE3wYNpv3b917uuGiimBkHKj8VRQ0lsT+FowqNunlZKSSVsWa7qYSmZVLUgdERYyDLAi6PMoYVmopDgdAdKtFm9lgx2zrBLCXQJS2+5+hz6YOmPqfLN+aAjxMPhrlJM3biZ/DvtCPaTMWP6ct+8ocFf4ioKGcjYrDcgkytTDGOvzDlmXQceeRS4hd9PB3eIjda7685B74bphzuc98Pi1u0Jt0O6ZpcDlUUi43gHrHhCts+MfRrN4efwgb17D9SL1zXwFQyznMTRy2uAXT9XmfAgcFrS9QvqZ371X6m36H9K/3pSRBlubRoNbq0MT4m79C/ez/gSk6mMwvW5OldlK2EC5LkFh+HcRNL62i5DAulDOdUPFlGLlr8XnjXLEvfkspkgfcsqSgmuuubda7KjSlmM2mXduQAns2+223UoC6FIrO2fBcqyU2Rd8d7MVN7OBfrHCgALek4J4qfdEafVryVQSRHzoeoeaG9+4sWq1YIC2RkP1P07YvJiMzx9Hl+0XoIz4biu3fo5rMVis2WJFRGTyGdZLKGBTg7g+XJI5SYu268qp+iyfwYUJ0ZWGlNgsbR7SDk7oWCMtw22OMV+/5fqFf4dcLvYeyj1TbsM4ZVkEpd+yCv7ZLJvZdbE0bt0akTGMq1hJ5McFf1O0TrN6QwFPjZisNTOb/+bYC7gvwcRXdbvKrlWpMC7u0hggRdTgPhPpxn2/61tvVXvLqk3zvwjxWQKsFlqAKRNcAuT8WjF8V4KPOJGHJpgEkRHQV+nGu88d+1jlA98qAhmLiJyAMBXHYCmQV9OFFH7Ls544q1DThmeDTj66oc0RUJyUMINrz99llS5WydGozEOCEV93Xtpj2hJjnA1dj76kD2MLm35mY6FUeMi3KzEzlVA256nvQRCr6x+GeyHmz9fAfEmNRbho+4usIPVPxJKBIe1wSwjEgq/5zLGbHKsGVcprQumtBVJqiojA94uHgi3dysEClIuhew614yhzlfmtKRC+757PYYFBFnCo4TvEBQGh4GYjKVd5K9poGxm1oivvx8Y0FMgqAaSi5Gjjxr04VORtP+ms9AsuA2Rlqjs2JQaMtpD9J/EcbvAq84R5S7ZMltvSlyU//PJDMMbHj+9ibJGb8hu5dnrn0mrj9B3QaPO7te8WbQ/u533v2tfOqVigs0v3DjtzyrOSMl1fqFlGPE4L11Xhn3Blw+X1r3/8OtOfX2Rim7Ow2YzLofHVQH4/k1FO5q5PWBggfXBihleENj34/oPBa6PN85PntCsnhtDnYYQULd61JAlNvlYFmTbKa9VI37XXCHgmMX+KlUaDbHyxQDJXCSDT5LuZ3yVbSYRuWmjF2WBS6OvhpTlpi5PsybvNYm2s7zdkIQjF0hDjkJKlQf9h3ubEr43FVTtdZdZcds2CBQCftM+WSpaKbx2T+kKaW8W1bPA59zNSIwT4c0pLjfRr6sjaSUmhpC0h66CbOcRc1hQ1XnNN7qdueWpFrjg/oydWMVaDVsmbuYRcsU1vZMzSzZeuSx+dQ59edN8yqf/pi5Tq4a7l56B1D8pkGpZsPnH5unEuzBPmbV7XtVuIM2TBYT7G9gNNiZIMN1mbD7z7gOW1Yn7veuuuSW1zM318y5w2fzm0kOAQi4mBg6a+0OBjRm6890bT851S9wCFllAcKg3M41Tll5nWfNaVQvN5a/ephvCrBG7Qo7tgWBhrtVjLvPXFW0mBmW7Q6KMfPmozlrKQEswZU3iYD8wLrZ5HLJAsZQ6F/NCpc0W+f+i6hxbFQfnQrskzU2QMpMQQ0A/Qxmv+7lCdEK0dmosTJYcN26/zotV3QqmRDUALfPT7VItPkOBTv9aPFig4dK+h6jOLL1+sZZUqzS6raZ7rMC79n+8fjCdwlTSQUvNK5jXWX79PUtZTJcDiC5v0q6NeNad+cGpmO+V5Q/E+ofGLXRMZQ2D8oJcHFW3kPsqRq6Fg3dll9qfIVm3++mUtCFqnqJ+r2PdaqVctZqQ+AQWwNokQcpiiOS2Wu3m7mrogdKKsFNrJHBOgWxCKNMOUoNJ5Be7DyZwTPxlBbowI948pIvIZ/+RtX589O6qMyLOjuMSEURa9PxswCz3GX6EhaQ7NrnMLuJAx9OMytFo5YpXqsEyH6G2wDPjPxT2k7a51IlQbiA0PV5VGKIUfOwW+j90/yUl2lFg3/PexKlz47IUlfnw3yNE9MYJQirS7bkIBmUKCpQVW3rf/fYX4IVAN6x0ZasQppJ4VpaIrP1qtK1/xT22nyBU2Od9yRZpoOYUnU8ApnlgXDowvvPCCun5knkj2H8AyNfaLsarl8qsZXyXLOqoAwwqcks3GNcvZI/iOay2rZO7QBmtJfe6SogKhWuwJ+Oez/7RKJj9YaH7+5Wfzw3s/mPpEg1dGqEmgTVAmB4tQ/Kp5J1vIhBxye1ZqsdDiWfwAPnDZC8VkbX5Q6bwEfVxpui3uBLGsCOSkFyJWEj6DrGDOLEGAIhMSZmycGiSgOTOI1NsU/TF0q58CjfmUa3S+obONGelmSv3OoSBkAin9+9EWlCgJmHTBPMEygRLjuqCEUMq38GRBI3MSy5O4Td3gTH6fP/J8tQ/9oaFtbvpqFlFazA1D39OWgjVmDk34e1++l5RumroR8hy3v3V7sjzQeD9i/Ztnw+MZ2eS4hi9PqMJbLbjWIEgiz9tu7uHigxnFPBoCNlfcSKmZiciendrvZIZ/MDyzPcyXlPTrSg9yvpIQGwfiPp766KngZ/JYfUTJJI7JVVJ/XeVXy+haH2jwAawULqImgQ/xt7Kw87J78tlTtzrVCi1iOoSxEmAR0HDdrtdZM5vPqLl3h71t1gzmb0o/pwSQhgL4NDIchJgElRLc9VuHdvLmueinLGIlef48Y7nHmntYRUIEjpohZeoypHwIy6cNaJ5dlxIon/fb4MYc+DErEn/Cj4xjiPmUeUBhNy3uRYt1EQXCnTcyZ9hkQ+B52ZywkLjtEAuFdn83oM79dyyrQzK8KsksiikiAMUqltkhMQdYldw4hM2W2MzShGtBmNwXJlP4JNyxTp17T058MulzBHi7geAaUhmNbUxUh70L4+kSN0qQpMyNPKRwXBeXy9l/ONsqb1oAMX2F/MNd6CoijMuNk/UsK8liwlqZkonH51MUkRAxXeiaWaiEgLGRaWTnEF+PKSIpHFWavPGVVGjpQzFz8xoNXhkBmPCJBdAYBiUQKo/2y2dxG7gbGAGrCDsovDUcef+RdlHBqOninrH32N9sPqSJxSZ1bCMo3GdOpoefzYJPGNZBH/0697OfpX/8qG9NAciLGI12jGHTBc/rllwXwLug3rNRumDgNJIi5Hz3h3oanV0XU0GMgssWy2+UHp+B1d2wfYhipfWTdWe9dFVRWySwMpQZ4TPh8u9XJr0SfGbmS8gFhSDHGqEpZqKc8yPPSuxHVtZROcI8xJbsf4b7xzI76E9kgEuNz2tUfw5dmz64d+y9lvfDlQPVdocOe2+YJdrz4c6dFHpwwAGKdeQ+kx8kGWMDDYE0eFwuf9vmb+a0rU8rORBBgIarRWMD5fQe6zNO+CM/Gln1OLhK2JtJBUZmkpknmT0azX0KZpvZKndMKsS16HM7sb9pa1djdJ1faPABrG6wH8oAE1tIrLJIgarN+hfy0TOhOYkSbwKza9Y9JdAyFTHiIp8dVdwFWCiqwbhJlDwEZbCWuvcnwMqNCYgFicZI5vwiWnkIyRgPcvp9dlQNfttCbfL7k4WvBeD6ZEdacCsbAsqZ5kqR9riMqlxzrw57mbvfuTs4z8TknUVk5WaYqIHSDlsliPU7bd2zw57RAEFOhyjLqa5E4R4BoSBgcaX6/By/NzCuWBYkmy7IaKpkxPjXyZItMkfyrCWfGdcNQg5V3BX88+l/2gJ2Mfx5kz+bAS8NKHsMt1hpC1sl3Y3LkuKGeRGSUeUSOjYO7Akp0GKDXMK6GEtxNSniU/fvBm8Z+eKnL6wQ7PVAr5KaDFnaP/Uo8mq7scUu5aRDJ7cYf4mLy567zFphUsxtWX5yIWgTDhZxF1QS2OsC4iGNPp0AK7colVYrRxA7+bnWorwF+CTGxXWxhCCperHTqNaf/H3+M+er9w7xmLhWBk0RcdvjW2fueucuc9gGh6nfIbhYTN5Z80zaBCiTUPJ+RmEwv62+RdAXqn/a8E8Fix6Kdow3xeUe4Qeqew1wUhDro7Wtz8bztpRANeG62kLF1FAatYJ3/nVicFOFY5Y5H3Laduct7SVeIbbp8Sy4wbIAp1BeWcScIp4M68WzRz5r3UPiUqMfNCux+12NSycko8oldGxsGltrVTlcRaDXxnOrErvrUqzLWo0ityDh/EaDtoxc89I15ujhepyEUD+HTv+iQQ5+eXBSWmkKuCaTT6rCVnpy007UPkInePmumz/vXg/CNTa2eRncxcaDX9O1VoXgUm6HrEX7rrWvSomciqxsG9+SATQacPfUShHG1IwEsZClnkgpVPfipy/meo68SGlTNVJA/QybWA0oScuP0WC7taS0dF/NIubX/Cn3xCpgM/xl9i9Vkx/Sbi1IvKgERYaFJPS8uLyozeVaOMhcyQpKD8nSrFN4OTV48sxt30qZuq7O2/Y8OweFATVm5Smn1lYRx4pHAV8ptD6njWM/H2smvjrRHLr7obXU3vkNBiCkiLgZA270vMDdWFAcqgEmH75VUUQkaC50ckuBeyqKcTZomR78jdXiiQlPlFyPlLeQIiLa/AbLb1DnUipT1+U6uC+kP3x3i09qxesxem3SUUnNrQR5aJsR+JxEWfhuNpMr8EJkVSFCIrIaNKbNEDRFJOs58oA2ynOhVPV/oY7jwgcbHzVJQiUKQqmmbh+4GTYyF7QUTjBl+hT7O0YueMA6B6jpzHJPNlg3ldcnYZv07SRz0L0HmUqw9nJr2wwdLGMx1y1KQLMFmhXWQgj08zHDj1HrP8k4SUYMMT1ufR0NWJTO3fZcW4uHeYrSTDaey6mShZT4hJAyYmVTTqUvdW77hHB5rKb9nuin1qrxs/zy1O1p5IyZP+9RRKScQN5CnC5Clhv+btm8pRn+Vlpw77xCg1VGiL/IgrsZSsqZVDeVOhfV8jUz+W58/caiYLfTHjutkK0Qug+mxXZLtwum5moL3vcpW+Hy+k0li95VRNzrDX9/eDjf3syyfUZWUCV9w3XcE6Ns8C9NeqlQ3tuv1hsqee/yDMwvuGy9okCFeC7gNBCyKmHqJWXR3yAltfi3AixBCMcsLgaEIM9419t3qZ+TlM7UE67MhdD79CVWMOZ4CKwZLX3atbRI0DFZbARgimWOtUTF70rA86GIsAlqz8H7ZLcRt4ASIHN9gcYLlKR0u5BrSY0WbQPi31iP6KNY3Ncj4x4xI8aNKLoun01hTyVrpv0y7e33yCAc//X4TIZYIb1jKnz07Ud188qRSdWwRsl9/T7JS+HgjplWq4ZnSVVExKL1xpQ3SmLn3IMxyg79JfIvL3BLphAS1hcarJuGjSGlmmnMrBhidMxbHjzLlIhvNeSCcM3N1I/xtebUaqT/2ulfSRwg9AkkT6FYhd8qymFg1FCocpkoGP0S7Nr7KJwIa595VAKGNVdEpaiWqyZLgLvMmCEXQagvK+HeuWyHy6KbNrECvtsv5hbwK1oT/H7CTSfYNOqY6y6LzTfkRtKCMrNcx37Zhwu2vyAzQDTLvVku/tDmD7Y4m+/mElemzxCbZUWQisUuuZzvSkqd0z5LsFhaR08eXTjUletazFs1PIWAroknw8sZM3efEIs41iqxLvvJHNVELYA1A2iwsVOmVq1SggIFGm8HaWqpgV1ZkJODpOMiYH24qVha0BUbIZDCTdrpXBZyChDInBIJ3Pq9QARf1pj78D9rTzA7XWWFWVYwoNu3MCKGFBFcc2wuCC6UDj9F+OPvPla/i0XM5YOYV4qIyztRTmVhTmOy4fCbNEc2YnfNaMXYeJ25Vs46cuuJaOi4fMdCtdPUQGjhO4HhUtB1ma5m3LHjgvw/oVMo/S+F+UKuK7I7tHXKCdmVOaGxp77MkFeGmCxUWtQxhKcmPqVy2kh6u0srkGJFQFllA/XlLSmzEtg8oNuApLZRMVfgBtVyYMA1zrVY3wRmu8GdKetMrCRf/hAvVMr1SAFGOYs9d6M57npXoaTfQgUMQ+DzyBZ5VhTgWJG9+kCDtYxIAGvv4b3tRHc11FjgaCjN0qdgzqpH4mr0qSm6sVQstF3tVMc1snzDKVYDcR/IyVCe8dmPn7XP7Z9YXOzTYR9z5zvhtM15heM3Pd6sscwa9tlhbkUZgc8F83MWULbgGHFdJb6PGKQGA/oghgLXRSioz03JjZ1yXDZMv15OOeA5iRP46defzM6r72ytB1otHrDzajubhz54KJqyGwpQ9NeMe9pzT80pFkx/nnIgiFli3GdF4aGAmsQg0e+xUyffoZhhp+U72YKEnCSn/DClZF3yOTZHLS1cAmyzag/FLLPSfwR4x4KyU4LYBXmCW93rb7/q9klrSgscTQ1Uded8qH5Rai2nrODl0zqfVuSeRykhcDfPGrMuttFzOWb8+zO/qQ2TEqDbOKHGUhZQAEMWVtrz/jHvF+ZzLYC1HnDEBkeYJhOamDYbtjFLNF+ixFSO395fnFpQqF9nA/hVSLXJFQu41MqaiyXGF9q8DgmVVjcjRRHhGhO/mXta8EHpdhaCnCblWVst1sqs33J9K8RDlT1pw3/GhtM25yUuf/HypM+J+Xv0pNHms+8/K2zCQIslkDmAQINLoxzXD3TucH6ErG8xRUSj/kZJZO7G4jdSLCK8T4Aec6n1Eq3tGDdprKfREjtEefQLR16obt5YfUIuAn/N+FTj8l5sXmrPxn9f/fBV4Zr48UPjI9YOITWUjYe5MOGbCfZ7fn9J7A7903ulOtp9f12K4qq5PbE0SaZPKF5E0LFVR/PK5FfU2A/pP0kRLyeI3Qf9RfacVttEA8+Jy3bGTzNsfF1qQKvPVoz8yOJfIuXUVdA1JctWZPbo9zW+ELEmcw7XYrjcWDWuR/Au8qDNkm1MKrBKsTb8TCmehfnF9TjMpWDWHGuLjGFeigIhPQt9h/4Y9/U4U99o0MqI0MF/+PWHpvfQ3iWTPCTMsqLANQHLCQYBB0TZQZCEgtc43Wkl0TWhrRHqsOi3XHlL8/TEp5OIodC0Q7j6lasLTJKhSpOcMDHBE6XvBmP22KhHWeRBIJb6imUBYRIjykrFCZufYIUDGy/9zG8B/dti4RbBTACsLb4SmLrpE1CrnX5jgiMmhNjkvpz+pbnwuTrXnAsUXwLkUqEV8dKegRMkgZWkOfonL4Kij+l0TDQlO6agMO9TKcfdwG8UDNpNf2jjE/uuZIwwx5nToZMw1xv08SDT97u+pu0ybYNBsD5gVBaFHrdDbK4Qw/DCkS9EycHgIMqCJq+0jDRey8M2zecody+KnDyLMAr7bK7Ig1A2h18QUgJ2N2y5oU057bJqF9N+QHuVP8UNGPXbp7muXYUoJS5JOHPcZ0zp82WaL6NeS3g+ONylYtYcVmOsanmDbUm8iK0D+qPdUu3MGyZdPswLNNiYEZf0rPdDdYqIO8nFnyyDmKXdhyC1HBDIbn2RkI9a2BTdwC7x8/EbkzlCRO5/x5t3FNFUyzXu3f/eqCKCYBBiqBRN242mR0v3ybQQ2mRWsFjEn8kCQhiEfK3iqgrhtr1us0qHFruBi0MjysI1kwdigSIWwO/nGIGZpNoC34/N4k8BriM3vkiEtTbnBPQ1/a+R2vH3P5/7p/q9PIqIe69MQT17ls360j4bqpfkQ6O9j9WKcRGaW2yqsum745MCkQG4b9wyESWfM7OKTpQhxVWzfNEnIauo2w7Jogi5unjOLPjyinsLHb9bNyvvidtX5OTfQmKnxowEgFLBeieOwpZMOH6itfYRCMuBEWUqdCCIVUPX0sVFIcpD3OZeK2Uu8RktbsQdi1SafgGHvHLmNG600HdiZJLzGw3eMjJ55uRo/rs1/TlhNUyeag1eyO3CyVxqicSqmYLQAnzsw8ei9+YzPBtKT8rpKqs6KkAwIjxcV4GfOy/xOChnWItwjWFWp1y6byEg0Gzfu/YtuodYZkIMsFNnTE1+Dulv3xfsc1qQ+qwJVjktiWmfjYNnIosgBVjIbMAqQ0k3NdLnReik5puqs8z+oT5gPDTLRirENRHiq4m5CfzS9vRlaul2IaA6/YlSlk6+K2vYtSZq1PuhZ+LzWFf2X2d/q0D4bhvay4nSRcqpVSytWWMlCi/mfDfzQZAy3r41wg8W5Td/0z/Im2ohJJe0uaDR1/tzhQ1cq4JcULJyxHBzf/ffBKUjf1LWDp8hKBuE1gt9LjGHPjio+YU7U+N0fp2jyHKg9ed0iING45gRS71rcSObpr7R4JWRVs1aBfPfVar02cWTOWb2TAHXGrrn0EKsikQ8i3AOLZCshUO8RNb3WQQI/lRTuAvt2rQ5VLRKPnvkhkfaE6fv/3VZBmWDPGnE3GBZ9x64HFDYtDbkKWuOUKHPOR2GEOJV8E37lz5/qTl0/UOTyaBoO3E+IeruFLO/v9Gnmm+59/0H3G83H9f8jxsxK0CP6qt+sDLjRT+GBGvIrakVE0xloy0ET7bbXlVGAEq2BErKSZi/l1xoySRuFJEBrGutWrSGUPyIO0/zuEFcF7HPQpsVawEYi1GfjirMEc2CwN/Ms6ysjmqkgvtzQaOvdzk7IOMKtskpeCk1kLLAM8j9y6kXwxiIm53DklvFWa7PP0PkhIydC2J08gQM7/+f/c13M7+z8sGd01C/81zMeTc9+YTNTij6vhbf+FtBg3fTYAIctNMgtb6AZrZk4vhVDX1XSmqqlFtinknGRlpS6bVCxEx5PAt8IeWchrut1k1dqKRUxlLgiB9h83ddSy7LoFQTbrNEOIYF8zbKTKgmimb61Epox0in8oJroLSETkra5zXFzTU9Mwc5BcVMsv7nmctZKYjcG0XEN//7glJDy0ValtSzOGXLU2w/suGRieAj5NYsxy3gm59DVbABQllzZREYSuBlyEQuMsBNhdRcKvytBf65lbFxuZ7R+Yyynk9T9lEWRc7Qvou6XpQ53rLmrFyKfTSwDMR1jPukUtK9FOZTt67R9a9db13pMD5r/eHOfVy3WRBrSrn1Yogjcqu5u993XdnCrBx7dlzB2oErBlHWfDetKCVY8pCjENoxVCj3v6X03RgavDIiWTWSaw/5F1o5ptGp06dmTqhQYaqsInXa9xA06mZWZv4/iwMTZDnf5zkv2v4ildtEMil8wUTb2Rx6duyZ2a4QyyB9i4CK5emLuZd4khA/hatcDuk+xAbIaQqnnC7nFQgS1jhJQlwYbO6YUFO5ILSNPiW1UVMOUtx1D77/oFU6emzYo8C4e/7I8wvxB1rRP8oD5C1wmALSSfe/a//g+Pnl0N1DA4GX2lo7+w9n2zR3rG9ZBwPGynfTCHhe+pOYmXOeOcdUGxJg7AacHrTOQUHOE7GE3v/u/er7WH62WDlsXcASSTxMapaNNiaaizuryGWv4b3MUW8fZU5+rNRix/fceUz6bep8KlcRxmWvKTIlipKZZWn8/XgwP1i4HMxylDVfyZBYJCj8fWuTH5Plx2nVNxq8m0bAKSNEvOPGO/iLSZvUWdk2qcF5cu+/bvZXs9CCC9nrXvDMBapZr8sqXcyTE58sMZ8vvfDSuRcdhFr9tu5XiFKnyJN2KtQgZuVyzLoEwArVcZaC4BJAafwU+Pn9NFEtdZTfsayJSuBWj3VrHIlPWUv/1mjkxf2HlQQTrZbaDfgswdgxyL01l0mKu+4fT/3D/P2pv6vvhcYbf/YSzZYouBfK9ZnnuacfU6C5hLTPn/P0OZkuUsEhrQ4p6nuhMsdlEOOkEM6ecgtgCqxK78Sz3fbWbfZUzDNobaePqTelQeYc1gXfVca1SEUX5TnWZpQ5rGfwq7htoz/JDPIzq/yYPO0Zg+9538uKtcr7LBoYU6xhWd9jjKfNnFYSD+bK/0otsrOUjKJQxW03G0eL0Tl03UNNfaNBk54JBe56W61n2l3VLjo53A3aRYiIDKGgBZ2V46fMypsXMNFcfyECj/iMvAQ5PilRv8f62dOv1p754WfWoBFAuUqGu4mDrHgesmlEWeDaxLaE+nlgt4GZ1Pkl5FvemLvBpxpBnk8j7xcK9J83T5VTv6YP85TA30qp8lOg8UM88N4D5ozHzzCvT3m9qvcSgjKUgxApYCXz9Zx255hT9jvF3DjmxuQ6JECr6sy9IZEb/sHwihQU1i7zqRzlOotuPquCrEv3niJXyiHvyrqmXDcrWJm22hgvpSZXFrTnTKGlzyoN4WKLlbawLLwpc0r6IGv9x6on10jPfiOwBDgZg07Nl23bblsohBTLiBGKb20TKVcRAbQRMp3QZGfxuZOdk9dbU9/KVTlXM+Hjm9eUkRQuDVwLKy66orn4wYvNsC+GVaX8um/u9YOy/AwNaUuMjRJfK5lAxHFwanpywpPB+2Ouzty45pyE2Bi0MRfTKe4AXFuadc0ln5LPE3CMGwclgg1Wnh+kBrC62UJzm1vKocBc+Me2/zD9Hu8XvZ52ndD4insBhtfua3S3SkhK4bVy4GY89dyoZzLfiIsYNwPB73kKovknWpRpv6rzFS9cUah+LBV7qe77p/v+pKap+uPFddiY2CxTyctSKpVrFWQHvjSwhOcn1L+aXKk0ZijkbkwJVpbCpMTCcLDIk1HId4lXc/mUcEVCACmZgZrM5bOpWWLPfZJdyDWUKhy6PvcPxan9FkjPajEjTtpYimDT/HRuwBoL1c2ocGNIUhZfls8TIR+KyXh43MNFk10yQfIIJAjAfOtBJb79UZNGmU4rdDKHr3i41b7pIwpelROnwXfgIcDcC5Wy5u/UzPHuhq7F8/D3SY+cZBVIiqvhcw35cyXwVQue1TZdrhUac8aS92MMoVrAsVtbwuWJyDJ5x+CSTclz4s5pv1T75LGXWiHEyMTGl3uxAbTu3zqXIkI7iGNCccxTs4b7QdxH3+Sdx9ftep2ds1gd3ZgjGEGF/6Ic65/rymXTlGBZXCTMF9wlkAiu2WJNVREBfbeYWzvFd9nRRx+d8JFdL6ngGmzKsQ3Tje3yeX5C/RCiQ6gklVieF8RiH+gHOEu0WBraC+syPyVtNo1t2njo3nATuXxKHNZIRGBex2S89l6fjbMLlKYeymLB7qE4NSE9q280eGWESG2EAtS9qYWQ3A1NAoEAQkXjv2ABXzv6Wrv4MpUNrr/R0dG2IAgoVhf6fiXA3+sjLzmQRtQj16ECMamh5QhwhO+CTRa0SoNGTgayFD4tqJENXTaBUICtX7SKYLkUBTbFelQJ+H6PYT3MoJcGBf3Fea7Fhs1GKDENCFh3Ew8FJ/IdKX5GXECWshaDdn02VSHCQjGAhj8vbN/MrrsWtUNSSKO++fGbQpaCHDj4TdB77CDDa24xOy2bKxbPgnVEUr9DJn82RLdNvsWPebpGizWizyftEuUzNeU5j1WD+YNFz1ca8jCQ+oSHbm2ZrCxG+oEyDxomfz85yIlCWYQSwsU5CgAIWVzygP48fIPDcyvJtIvkBJ9mQg7GzFe37dJuiVMLKbH1iUYNvVAe0drlCHAEABurHwiEmS7krxU/Zcjn6qJf5342MyFkOiY1kVOydo9KNiQWO4Led0eBvEXLBEP3GGrGvTHOdOncxXT+d+eyFCbaxYk75M92i57F/NB+rElen7Ubb/HY+MeSCLR+b7BKZ6NixZbXiL8g68IfAxkbN0aqkniAP2/yZ+sC8IOSXVRyfVkj/N5nrX1s5kEIo3qMKgq6LPCOLL5Kwcd+1INHlVh4KLQIFb64/WDA1QKtQcjXv02bbWxQutZ+LFApxe+y+knGFWvfcx8/p65vMf277daum+Wik2u5buvUMZRKx8suvKxpv0x703bJtsEik1pcn1ZAT1KWYwVNpY8oeghjMvM/JcYqxV0qbjgONg87BRpDbmy5put6dgv5ufFy2tjwrDKX/bgziZ+sz5iRBquMVCLMmBS4CjShnHUadouyUTE4BNlcJ02bpBZ8IxaDNEtXCFKEi3z8aiBUnbicPnOFfzmKUp4qlyhxtFMz//tCPEu5yhIovL/nmnvm7vN5Gdg7L0Ga94qLrxjdsGTecGI796lzrXskL0ThQ/DTT5piDNxKv+UiNha8h6tD7u3HIh3a6lBz9l5nq8HvbpCj2yda4HHedYWcwYUTy9ZzA7YPv/fwqDtMDlaxbEJ/wwP+dUUBS9ncUV7ZGFPGMM960YJkWedkBGq4fe/bzUfffmROGXFKoXq7di//8Bkt7Ddnf0ARxe2b9Vz+/FhkwUXUvQX39g8//6CSILryOqTcxmLmfgvKSIN101QSPIX+pgUdMpmzFg2LDqbLGb/MiN/DzLY1P1ZfZnX1fTRpiMdgxITLghMcqZ+pyHIxaO4oUhfJ5slT50Oexf2dFzClsoBSYlewVBCYFmoHjIcAIQhHRQiSihjiWZE+wm9+8hYn5+Nv6XpR1IRfDdjaQx32LjLHxnhj/O9q/YxgDSlvbpwSmxon0TyKiNsHXAMTOEKX+3Et3HE+XP6VWB9mxa/E3hOXnuZK+ffkf5vzn9Wtl7zmx43hdtHOfnlrjWjEiwKtlhUxbCFwTza/mIuP1yHxKtrg37yj5LpYfOEj4Vlife7XLPJP8O58xaqaKjfkWcQdJH0RUkQA88sP9NVcatJHsdRwAYdIqUUWk1d+LBuQOmb+fKDPcG/DpqvtW668DslJ9zM1npHfEPJWPnQhp/xyT7jUW9lule0yPydpYtp9rnvtOvsjp30mMHVeUhEr/e7eH6GncbDgt8UPnJdBMGRuDEECRvMEaMauJ/VzYsJX0nKlku9fR/w1OE+4xkXPXRRtj89T4/KgIORe/vRl0+eh8oLYtHuJ8KJqKhYGnkNO4wif2PNINlhIoUtBOWtC47GRsebfuD6/nfmtpb1GKYYUD7M5VpMYGRfPA5FhVip26LsS1xE6vFz3at0aTDmEaBl2AqH/hwMjdpr2N12/6q5PpEiqf8htIvMxVOfJBdfo/WBvs+JiKxa4gLRnZE7zLGRLxfpcssOYrm7fyb9tOYgtTzIj3h9hUrFnhz0LfZwiW/x7yr8l3sd1qYX6CMoHKACEP4hYK+I1YrwnmhvmV4+bij7kwOu6gbkHZSdCkGug0MRKM8A3gnJZ4xn5jcWM4CpxByx1g8TVklV1s1Jk5e277ZGALs03qgGzI4JWNkSEKunLqc+ZFcMRaytpcFLYyX1Gv+/L9S9nYdfVdzX3v3d/1D2GIKyGO0D6UCsD75v9884lGGjJVHK5ZXw3oWsS155H/NZcSwr95R3TeRGjkgr6jSrJzCet/9gYiDVIXReFNnkKAynaZDBp4B6XPndp4fqpMiQU30CWUex7KIuSsZdqnvetD7gnpMZKtdaW6z4KxWmkQvoH98GqV62adv/EukwpbSL7Zp3l1ikchIaNHVZSTE+eF4gc1bilJD5DitNpa6yJNx/K6T+uQbX29758z3ReubN9TXP3+GutxjPyGwAR8U0mNDFvL/a26f9i/8LAsxnhr/5yRt3pi4JIIvBdTblaisjKi69sPvruo5LX3dNhDK5GjJUki/dATnySj8/E57TjAy0/9JwocP94+h+5BViPjXoUVZi0J5HZjaypXRY+RbuACMtqcBK4CCkirnuMQFj3lCJF6/zKrVnCkRNeSED5Zl8E5UHrHmRZMrPuwWcv3eFSe02xslCcy3ej+Iyu7vOEiNPmpyICOrfpbJ6e+HTh7zyKGZ/TOHBE8KKIlLN5+WyhocwPCazkx523WQGJblaXG9+BKycE3LFbtt6yaIMR07tU3dWKfrKOfVcETL5+Smil8TduJXCuiSxyT+f+uMaUNumfLVfc0hzT+hgz8OOB0Tlh+zjh0MbBADd5VoVqZJuQvGElDLni5Hn9wp9uQUOfB4m1f+JmJxbxyZzgFbQL1cwKHVB5tk1X3LQoqYEYHp8Di/v4DLu/FZ6RBq2MCFxFhN+kNJJGKBs1ZmD/dMvr5bp5fGiKSF5IhVLZaDDFCSmPP5m1ia89B4tJIxVymTPzgHt3adulxAKDsFp2kWULC1aLfcnrVmOBs8k9NfEpkxcanb8UrUOIk0obA5TYay+7dlFVT/+kTeaClha4/GLL26j3LKubyzXjKpVaH7kEa7LBhqp3luu+rCQo1x8jroUbsZJMJTdlEQVLaxtEaGJi11x0LrIq5Mr88Ktxk13Hd6BH9+/Dmt3uxu2K5geuKA3cm9ICofITrund7wPaYmvYOG4vl0YcMC+ZH5VYxbiuW3HXV3o1d+9eHfZSA8BdF1nXZbqavrv1NS9/9nLRAVGCTlPo9aUvGFd+WMdZZQiEpynreXFJuePLb8mo9Nc9Vkm3D3ZcdUczYvwIqyBc9sJlhc+G1iHxZksttFSJZfMPq/yhJLuStjNnfGI97uPPE3hG3jBvmPpEgw1gFYydPrZEwDBQnHLcYDAWKdHU/mliXgQflgMWpsvnAReDcBAQ3IrlAf8mWrVbyZHvZBUErNYznt/lfCuktOJwnOpjwVR5Cb0QMs989Ezm5wjy1J6PjSIU5BULSuM9rD9Y1nwCOgkeiwXPXvbcZTZOhRRwDRJDhELncyvEqvb6QYMhpARTwtGBa8INjsWaWEnRO7+t03+aXvb3z9767CLeDS2gjz4SRcQqP1udbtcKZnct24B+0bhT3CBXrRo3bmBiJ5i7RUG6Zpa1VvjzIxSwjnImhR219eMrIrzGAYpnidXPcqEF5VdaxE1I3fiNYoL8cfvunrH32Aw4jRMDwIQMF5Qoe7069bK/2ZALX5nzG2tDiAtJguAF/FsrYFnO88aIzvygUV8Ze/jDh1UZsZK3DnkuIfxzA7ehYSDLCdeMBgpCIjtlDPjB2uMCt99vgWekwSsjIXzw5QeZ1XiZFKT+/X975wFnZXH9/cEuamwooiJ2scaGvdeIGnvsLVaUvLHEjppEscWS/FUglsRoRBONihosKHZjF8WCBVFJVMReMGpk3893lnM5d+6Zeea598Ka7P2ZzbK7z32eeaacOXPK7xAQmcI+K++T3sDcDIUbvkSXRytcusk+ajzcOBGCbG6YjvUpULIeRGhqYit9qoSeOvfEG3sH3m//Hvu73VfY3QtGXVVXTpsxdluQKgCVakuOYCUbxrovG0VIqJRD58+7sfgt5lUhv0u9C+N45oNnmhkQzCOEeRiFr8cc1+O5y5xrCmUrQ0orW/Izm0asSjD3pW5P36X7+s1OCLeIsQmFJ0HObDT1CHwrnT0XVMllDGKKbCXIV7nIzn3k3BqXVQirKmxRFW+BlfIf/sz8wNWCeT1UmM/c7Ez/b2szWb7b8mZmH5ZcYCkw0m4Zc2ozpbLLysKaa1ZxUN6ZchPIUeYbX1ilAetuq6Fb+aq9fxz1x8KK5564cEp6bviu4gLWwEKCO2VaQxQ/Aq9zAp3/McXdp5m9UZJ1HBtzWmebxZIXxAqmx8HKgvo+ZNV0ejdN7zl6m+ZX2PcsYWGZ7zHLx/gvPGvnFmd7zdTyyeqiWbFYDznlsHjmm32+6HUs9htfutHfjxRW7SLg1GAKSGW61bEbYvZPRW+H74kJUQdTkga8+ZKbuzUXWtNdMOwCt/SlS1f5VOeaZa72U2NQf0XMvI3Ei+y18l7RCqVhH8R+L30jgpXS8rF2SOAr8RsI0dh98UUXIXRjCf48+s81v7Pm5LJzLOtjT64ZfU0yQ0r7uNngdFCk+LwlOJTfx+ouMbeZKwR5yvzm/RecY8Ea03mjHCs5n5d5hFJlsZimYhRS3B1eMQ+UGmjhddBhbjXuVJYMygjmdR8z0XP9GtK1cDN58YMXzXtpJUnHKMhhQ8+BWHuElbWeMbPmWqyd2s1lxVORbdZ3ub7+uhx5EGbDWIHC3KfXPL3ctIa8I9bfHOx+4+7ejSSxN1bbw/655MlL3Jo91nRPvftUcm7HrGR/f/3v7pPPP3GrfLaKW2L+JVxHoNMrI9SXwH1w0siTqn4fUwrEnaAnSMrPLmbcqE+2rd2/LGZMTs7hhoW2T9AVQon7sFmn+B7CmAZJCSuKBdCxG6ky11DR//3Vv9f8jY2YL/FfwzNx+bOXu7M2OasqAE14JKR/wjbwbtrXWqaIlYwTQjxHGclFKs0akJ2AMJ3WAaCx4miaGRSz9rUv2+9ucSaEvnHt89bPPWH9E9w5j5xTYy1E8Q1TvGmjtYk1GvSd+3nm0cG3HuzuHnt39mck7spSQlg/1n22XHLLuqtx60qvzNmdeu9Uo+iFsSu5irnUmAoztrBWYeEBRRk0uDaY0/UU3YvNtfDvlqIQ2zCxGBC/ZwXqatBO2o4ss6xdViHNsorvuouu6x7/1+M1irY8X4N4FtoAa6wVxBuy1ra5Nn/g1DE9Rf0DnnnvGR/U/ou7f2HKCBCTpT+782f+++mXnh4lRpvW6PRumhEfjvBWkBh0TY6YOyFVu0VPBCtXXRMYcZ9D1jjENGtjkpNnYjUoG8chJ325t+UakramyIL4DCZ6a5NBCeEkqv3XfD/5vpNtHomEcJONjtM2p+sy2GWFXdyRw4909SLWN1iMsH6E0GbgWHxCMxHWlbj+hesrLiWsT7dNvM0UVuKLz+GVCMFYwUtjbRJsVLHPdCQoHFmmDVj1tLla1y2KZVOQhVBvNW4sibrYGoGcKbdwmaKV1JiSGAV9giZ4MUepYc4yp+kDUSr5Xf8+/c3nMxex6IgM5HtqrpEZZNXTASgb4ZrhZ2QgcxwXKMzHqYJwtF3iJIqsCvUARUS7m/lOTJF1PyyM9COKZqgkkHF0Sd9Laj7DddeMusaMWZNg6hC8k6WIiMKXI0tj8256oFMrI3Q4J/aUmZIUP8/wGPjqMQOH8SP49XxFUSP2osh3K7B8wlZwE5O4HoWE//E+BG+xeMKNDaQEqzeZRsiM4FqwYiVSEespxEpe1xsH0mvuYpMsfQp5Uqw65osTq03iPphUVQ8FYSEqMgaaBTn1SawG2RpYJfQmNmziMFMhop5RLpOtBZ+5YMSQZKc6F8RGdXQwuJizhWG0KE6J9pKFcNsrtvJXBJ5VVCE3DDK1AhtXXnBlU7HiKxacXzQHkHfi4tIbNzWDrPYyJz23RRBUGgu4XXiuhf39w82WTdvKJONn3Q4UN+3y1sytqcJvpQr8FRyWkCdkTCFPWYuxmCLLOqQDjMkOssAhLiwCKBZQApothFYXeYb0a867W/NueqBTKyOp8t86FQzToLXBYgnQYAH0nr93VaxB+PeiiomWT1hPEhgauQYT3vW7XO+OWvuoUu9Mu0eOG+m1dF2uXE4pscWas1EUWTvK3k9KXpfZpFKBq6QDYgon24LASutkJYKu6j2muNI4WYSpflxHFoIOdgUSeIYwgAk1BJwAViXcInp4feoD4u6qeQ9lBZN2QictGQ71BO7xbGJItLLNyT53fCjIhjVAv7e+Fwr2qRudWrpdcq9GQVswY0tQd5Hgpk8Puu2guthdAS7Z1DPCg4qAdaotKqPfH23KipSbsmgO0C7rIGAFiLKxkj1mBfwDLfO0hRkSOStAvB5rBZ8hW5B1x1qNUZ3HrAplIZYa5gnfiYsJA6VTlkgdYIylOwXpS4KMRc5QRBULtV5LVp/g3i/br7F5N63RqZURq/w3C0s0XTEhYja0gDtCT/hw0MNI5jBC2jJTFmnuUEVjOuaLhYBCZE3E1IIb8vSQqlMGgW2C2Emm2Sb3Y9ebapVJBc/F4lZi4NrUiY9UQmJy5p51bs9WmANxpcVShREMWgh7muspdSZiZmrtb8bcSzYBc4LvbMpaeGvXmuaIiREjST/UpJMq6xqm4xjWWWSdmt9J8KpmzhXKbstKZ7m5NO+KBPySOaHXwvbL1laiLoKYyBsFRd5SlgoL973Vbg2rB5alSZA64TN+ZdsZul9Aag6AeWef1/y9ZbWIZcpweNLZWdrCHM5Li3unDMgW1C5LKzsvRSpnwVKcxRUVrvmaDX/KIUZiXKru62aobPiM8S/WbaeQj0HcoVpuD399uD8csH7O3LQ92yoEvCxlrEFFlqVpiU6tjNDhR/Q8ospSAeGRRHWLdh1jX2SAxVIBivL5JY0OWP7MXM1dWyBi1gjuweKHb0SbdC3oNlrWG+jbm2lC554wVopSFraRhcnJD4EbsgXmABKg2LsC+osAzZAkKNVeBIdQLFv3i1nN7nnjnsL7w/iq54RWWFFO2LA59fEczRFTZGq35oaMNZ+NAUVJg75EcZNsG7k37WZOS4q7pGaOP3p8lUKlszLCz+v3Blgiw9TWGGSOx0zkqTkQYo0ea7hLnrgkmS2VuwZyrxN+lrCYYeygImiEjVj4SmL8Qhoff9VeVLIIjKUEyMcOT1gNLAuznpdYbBuBBMbH4m5iLqAYpPquXof8G24Pa81b1o9j7zrWJJLj8zr9/Ofr/DxL7ofgcIBsWnp+25KBCyh2mNaH70cOeMSdsdQZnha+I4JX29vSyQG7HwOgBUBY+TKVzcFiS20OYVBoTGMXeFNfE6wQkhlDDItsbCwiC7RZcw7ISYbPoBTE6n7UAx2bglDlubqNxN2wMIvSCVlEg/sONvsbRYf7QM7VzPailO62Ql5lZNhvcevEqMpzYgNkk75u9HXemqVjlrQJPLbp6tOcfh/JMICB1IIlaIsUbUnN5EsUC70pkIWW+rzGVTte5Yn6CHIcuFmchZVYHDk4hPw1fA9jf8K+0Xj63aejGXQIa7FY5SgapJVry1YMKPkoQSFfS+yg0gxXA1a83f66WxW/kHUvcZHmxhaFAfLh3wiktSwEup+tkhR7rrhnqXeNzbF6XEDC0aQJw/i3RdwYa+NfX7JTvS2r+bHrHmveJ6VUc2/ez0pqEJcYbmQLPmNryuGbGlcrz7Vyh5KfdXplJBT8FqEOJ7jUxhbzj8aCQmMRy/LsZkAUDP1+1iLSRF1aWeJnPp9K6eP9tlpqq+w2HbP2MZWCfqFipscg5+R3zHrHeDbGWAwOX0O2G9KwQkJgnm4vPC45whEhmMMpEvPRimII5b4VF6IrpMaYJInPiPUP91+1+6pZCgygSm5R8HXKXYlLM4cwTKyRWEiOWucot/S8cd81sT2bXLVJZWzoJywwqVgdQe6mdO6W51YULPr61j3jdY2k/4jVkFTw1HNQ8iU7hFT5XNAWK6srBxITpS1UtBPLWzhPpJR9rjIgAfJWHJvEL1jsvvyMNdNa8z9d9afeep1j5Uop3/VYk4SWIYSVZBCzmqYg6crH3X2cn8NiBd57pb19ob7b9rwteYgMDxcoy9JPMmbE5kBmZ4UjYPWRIqQcdoa+O9Q9+c6TrqPQ6XlGQsROgJsvsbm77OnLosJFJpZVhMzinrBIlnIXjC6WZFVqBQirUMsNC2JJTQch6gqVJUi+Yu/LqRViJpBTXXLXBXf1AXMTvppgKmZwsEhBOUnti91TF0DT/S1VMzUPzICNBkRLnheBhU5gnjazlskcyandozN1BASq5cQE8L5ANg0ZVx/PsenZlVLm4XwM62Po96UtZOiEPCOcqDWpXcq3bM1jrCu436ReUhj/orkfNMfMeou1n/hi/a7r2vBZ2odVrFmFFcO4iglfTCCcW1IAAM3tSURBVKi5ZtPFN3U9f9DTu7F0O4vmip5TYW0SnTkRFlkEWFDq5f+oaQfcPivt7k7Z6JSa4omyvuBsIVU6514/mDVemTVcr1LvK1YzpevMXd3sM8zuiSV/+cAvk+/K37Zacquqdmqq87I1l1LKdphk8ODbUws95oJ5HRbebHNt7toX2gOPZR3QX1bb9WGXPQa+H69zeJ2w+p48KySCQ26w7jQv1V+v+qt3k2KdnN5oKSMKmNXve/M+s/Ilm1IRiKpG+9fVGkHMZyebiSC2CZ+16VneJ0gbuD9/h0BHFjJBWzowkKAm2YhClFGWYici+gNFRDa2HPzt/b/5RfzmZ2+az5INP4dhk9NqyIKrWR65ByZPIXeCfdJzn7higiINBFk9nBz0D5TpBNRZwAXBOIaVicFvHvlNjSIQg0Tj63Ed8/4Y99azb7n91p1a20azOFr1MXRcCHOSwl8huP65956rKroVM+laJID0yU9W+Inr06OPu+3V27z1QDZglFTN1CoKqpA+ceIrKk4YxuugrOZuPlZV3RTVu6UQNUPx0e8dMuRaSgqHCEpRNFLcLjxdx8YUwrv+a/X31OE3vHRDZZ2BkNcCUsQzHjyj6ve8gwTOxlhFQ5ZY1t8GV23Qfp92hvjKmMbkxIg3RlT9fM1z17i+y/T1VuEylYklzol+ljY3g2U3RA7X0ptHvektMTqTjz1mUN9B7vkJzxeS18lzqJnFnNHFXq11xXMI5g4J96Y1WsrIFBxwywFVgy2TXbRINqWck45VrTEWAKs3k9hplXZssdQWFS1Wb7je59/FVZ38PTnVI+e4JeddMhqIpGnWU5sHyo+16LGmgBwuBoFQFh+93tHRyrJyXRFCvhCLyIiNzmLN1IoK0fsxJlsRZP+Z/J/C9lA75Mi1jvTjTJ/i0sCSYIFgXfzQYgXSQo7aFbFU3dxTW1ExwVitITZjUn9TQg06+h8u9MOoohuzwIU08lXPNdheQ8thEetwCKwvkH7lFlakPzgN6lLxwh8jQptxnThpotk/zdqYtIU1tB5K1WU2n1BJ4StWIgJgtRn/2fi6sicsi9X5W51fVYlXj7OcuFEgw9/nPENYYn+y4k/sYNMpPEmSHhzCsshpRmc2dpIOiPWLKaakoFsVt0EuuR1uL+SyWAFh6r1n3D2Vn1EMYocVaz6ElhjiGOkfkGsZu+KZK/whSeS+fLfwyPhHprsy0qWtTCnUDsJnn33m5p57bvfpp5+6H/wgbgIsi2+//dYNHz7cLbDqAm79q9av+TsWiaXmX6qSB56jgWqwCHWMRLjZ8zcRdql7i+IBtXqZFC25f46AAaHwiG0ALLSw9HqZNmkBFjuVpiBpoVI4CstOrDZQqh31jGnsfpL9E7uXuMSoLWT1fRkGTxkfrWyGAn1I3yHu0D7Vp3jmWY5LLQXaTFZBTqAbzxNzfNnTO+9A0KhW1sqMVajwcj8UohiHj2SNoUSKWZsNFeh+bXaKu9UO3KPWuotZIoiPqcc6st8q+3lrR2zTsfrckisyztpaJso1rqTQ+hdao0Olg7WCywjrigXiKHhWM+UxkDHHMhX+3cdidMlTPOU5pBHD1UIgMH2s+4mg9BwL6IyJ+VAPZF1I/alYG7DeNksZyd2/WwGsU7RAC9DEC/07G2gqc8GCPt2lyM6K/NssVOq8lFl4olGH5D9WgK6Yhmv4T9rihdzq2cB10KU8q54y3pKaS2wFKMsoGo5Lo2nL3K8oxoPT1p4r72meeMsoIkLspBWRWGGxMEAaS1DD8QVTovdzIEHJ9bi6rHtZwY+pdmrw3svPv3xyDEURkevDsWmGImJlPISMzbhgY1kpVqp2PSzF4Ornr/aKAAGUFkFYUQaVQAefA8kc1IRgFrgO4jMreyumiNBfovQ0Io8twjfujRyMxTzlKiK4d7BAoiBigeE77lfJHgQWLfvhaxxeRXMg8yGWeFAP23GYmMHzQmAlnN5WEdBSRpzzRdUshKmUmEmpRJuTfSDQacF6IsSuaSZQpMJU4lQRKr1YUGKWmLe9sFOIeoWyUCNrrhVcFlsu0V5szAJ9G0tBRQGQYNWygknidRA+nN4aQYr1FdAuToeNCDmBZdrN2TQY/7Il4g9c9UDzXcJYpyLUQz8vmQw6wwYFDCtAPVT2tBsrZ9EzGxmbHC4SUsP1ZsNJXBO/gTJWjrIpuCFC7hqNnPIVIcJ6OF7hvv3Q9ng8dTCS6+oFn8cVbdV1AQS8xtrOZy2ZK+SGMeLHoj4mqF/zI+k+4PAksviMB84wx3f3lXavojmQQ0dZ+YZSQxC35vqxPitWcKwgF//oYveT7j/xfCMdEbwKWjEjZCMs3E60FFJ9hwNn+TARPqRIEf8BwdXAh6p5EYju792tt8nMykborylZCC4XoTLF86z4EKE2DoPSuG6/H+7nYyc8W+QUV0M9JcX57F4r7VVVlZSgLO2n19de2vdST9gjQW/4Xy3mRh1XwPsRvCgZGykQQMqJ/S8v/sUUDJZJPpa5BJGUMJNaEIIjlNmw78uYf8N3FsRifmTTYCOoh2Z7m6W3cbPMMEuVe5B5wBgWVfYMM0FiwYPE26y1yFo15mLaz4ax+dWbV7m02IDqsQLw7m998pYZrxRzFVpjk3LVkIq84gIreotKzPUI7wT3OGz1w9xmS27mT70S0FlPwT2q80o2VSpupAhh0HAs9ifFCst4j/lgjLlORXbqcaynrXxGqoJLP4VjQjuJySBWJmw76zDWTzqQ13pvkAqAfePjN9ylT15aGJRqHShmVOvVCvAV+XbSPSf54G/fl5F5y/1/utpP3VyzzOUu3uZiTzYXZgUKsNwwJoO3Gez26rGX3ws7Cq2YkeHDXd++fd3MM8/shfbfX/u7+/UDvy61UNBiOeXHYhdiAozP0f1l4h2YgIeucajPCy8LctepChzGbFgbbOiTlswdFglm3bLMqIctcpi7/J38mBfp01SWic+VP/ixGpOi+GbZzE4YcULNgs3JpAnTp+FBIOjVZzlM2Wx07AqnylSf6vsJcoWcRhhrJBt+OKYQwhEzEguMtt63qL057QjL1utAbtZXKBDlPmSESZqqKL06w6bR+Ah5JwjJrnvhuorijaWCeWbVl9l6qa3d3WPvzk/nnqJga6baojgT3T9lY5/oJ07AOXFngs0X39zd++a92esuFhOikTvHdLtxWaZq56Q+m1Le+TtEXjrzSNoOUn1EKYJB2w6qVLgl62vhORd22y23XeW9Sdf/8XU/bmrskBUDFsJnvgw72N31xlSXF7Vp7nj9jqy1LfFPMTnjZdky57qjdjvK74XNRCtmpA6wqZEqV2aiaY02Zo6O3Y/NsoyLxgcdbXGOjzT/4w5/LB3rAAkXAYzUWNEn3dT7MnFRRDQpHNpzPWb3MqbnMKWSVLafrfWz6lorU07poXlZfNiYPKWSso41SClfVde0tflN3Ss8C/fxMRewGVYyLqa4d0LWWosu2np/Umn5HKfEGOW+FVMgG75VnG/E3iPcZStc5l0s9RYek3akxktce2E7UBpjBH9W7Ii4k154/4Wpljw32Qt961rmYpnYEQ3P4TD62qoYECwVRw4/0ozlIE20TN9xX6yrut05GXhSAbyMO0tKV+TGnQlGvhmnXI+5YEJSSMvdUqqf3GRTEaHPsVBrN1bfJftWxkYsHkXxdVhnUCbI9mPNyjsVpeSifCAfVxm8io9lIW6l3/B+bsDIAf7vzPVmKyJCrHjQFPIxq8Afz+15Uc8qRQRQm4YA5CJI/BMJCSjzHEqta0547QT3x1F/dB2FlmVkimVk1Puj/Ca97PzL1qQ4xk6JsayG3EyRotNnI9c3K/Jfn4DDjA1piwRtocxB+21Ffm8939ZuxMcjCtse9ql+Zk4bY2CB3/7K7V64lEFuP+qUYaLoEWaN3l/6IuSFSWU5dJ+9e2VOP/zPh0udtMvCsjDF5nwsA4J2o5Tl1AkKrTGSqYPLDbP9Y/96rKF30fMZQrZ66iLVCxRmggm1/LDWu7bSaasUHEVl6q6k2qARWt9CixeuAAJVmwFSdmG7lbEd9OQgz2kigDr/mXefqesdG5WHsKEWpb7XC/p83tnmNa2JRRYv4lSgH8glv+Peh6x2iE+IqFeWTqv9u66YkUsvvdT95je/ce+995774Q9/6C6++GK31lrFwvf66693e+65p9thhx3cLbfkVUydHqAM+DWjp6b8rbfoer5YWMxfGAqEFMNgyqQsp+9c5F5P+67c4Up34LDaAMSywCdt+bN9+mNbe6EynbrHddbCH/HRCF9n5OSRJ5uLxurTXB+6xWYbAkFaT6n3XAEmgYCQeEHe1Iz7c2KS2itFpEvSB9/O9a17+OOH3ZcvfemW6VYbS9JMIR3jK7GeiQWQ07Xli3/1w1cLnxXGK2i/Okowc/DEESe6oS+0swYLt4nEO2W9S5vzHBeiUIaMoBrNTvMlzgmitpCUEPBv4bCRNNGQqZc+p1YPVO857Qx/r1mNBeHhI4xDwyJy5mZ2tdhdeu/i/jbmb9nvz3hpUjT6XysiUj+oXjQ6Vne8dsc0UUQArmSnXE86fqfI4kXyBdwzue8Xi1kpI0unFUorI3/5y1/cMccc44YMGeLWXntt99vf/tZtvfXW7pVXXnELLrhg9HNvvvmm+8UvfuE23LA8h/+0xKtfvuquea2ae+DRfz7qNWFOG9pPSgCi5I2TBRKy8wm0oCSmoN5y32UgG4AI4WYoIggoWDMxHVqETyLkdT/whYUgPFVyLVVCU6mvsvEKck3PtBOLjKaB1yhyV5yy4Sm+1HY9cTghaC+n9EY3Ky2cBSkrkQR8bjZisyrGyqJ+G7bnsKae+ISvIwzk5uQG+6PFAIxJvQhaMcshzRKlFibJXIsB18AA2n3O7oVrNhYAWUYBim0CYQCjZZEIKfv5281jbvauTKoPi0K2U++dahQUxn2XFXap2uz3/eG+NdwhRWnN/O6UkaeYc91SRGKWXU0wJ8BKPT2QEz8GtllmGy8fwrbjLufQGdK6l4GfK232fEhV3MWlxT7EgbcMUu0sypaaligdM3LhhRe6Qw45xB144IFuhRVW8EpJ165d3R/+8IfoZ7777ju39957u1/96lduySWXdN8nvPzly+bvmQhh7rzkjSPc8C1iAseXd8q9p5j34DM5ikhO7Ecsb1wmkJS6xidIhkq90PEJCCjemfe0ii1JFk6YPmyVc+fa3z7x2+hCgPEwRI4PXQSh8MFY9PQppYbPv/LBK01RRLRwiW2cObCyFlJWInGT5Zhqtf+dmAOou8vEYJhVRaeMkdSbWWSuRWquoV3EmFi8FJz0EawpxMoxWJsmCoVA2EBz46tinDE5n79km0t8WqTEKaVSMa3CZdYmIJlQVamytx0aLZ4o2RzcHwp3q1gg85OCjxrQvOtYhbK1fYrSTiWNOcXv0WjhuXpAvaWiooPbLrOtr0lkWaV/Ouyn7ol/PZGtiMSoILoY8+HliS/7OBYLxLIx1+qpwRRrA88ctE17AO/3Xhn55ptv3NNPP+222GKLqTeYYQb/8z/+0S5oLPz617/2VpODDopHC2t8/fXX3s+kvyTGo9lfy89hEyGt1WOtyjXjPhxXI/D05KNM/C5/2aXqvuFninDx1hebE+TE9U70QYmv93/ds2qGmwYTaOAmA92qC67q1l9kfffJpE8Ks0Ri4N4P7f+Qf96D+z9YlRUg9wzz1kPTIu/N+/98rZ9XBaL9eIEfJ/uCFGj5rHwR/0DKmVXlc5fldqkoImEKc3ifxX+weFSp4bPhyTHsr1SfWUKY9v28T61CVsjiuuk5vu9fO/I1t1mvzdyI10ZU3uXlCS+b/Xf+Fuf76xn/3NM/78OckWfwnXsM3Wloss2861mbnVXTH7TLc8V0cd4iFnOHTfh8QnQdXr7t5Z7jYJ+V9jE/++lXn5qfs/qFTZkaPXLNfivv58b2H+vfb+iOQ93Nu93sfrP5b9y5m51rbgJWP+f07ZF3HOkue/IyP2/P2uQsd82ONtsrzzx41YNrgrGHvzK86t24FwcfyyIZa49er8illIs41WezzjBr4fvqe6UsQTJHGYf3Pn+vts1uctWz+WI+77tydWXc1RZazdWL2BrmObv23jW5xrkmZlmNVaSOgfVz/Lo26+mMU+Sc5y1yk/06ssjfuG7rJbculG0x0OaDfnhQlSw/qs9RPvB9nxX3mSb7bNPdNB988IG3cnTv3r3q9/w8ZswY8zMPP/ywu/LKK92oUaOyn3P22Wd7K0qIu+++21thmoll51jWbTrvpu6+j9uJuAA/Txw10Q0fNdz/PPrz0YVKBSeQ397wWzffzPO5d79+1336n0+zFREmxzOjnzGvn2PCHO7LSV+6593zrrvr7n6//O/9/Z/7/DlffI5Je9J9J7nxr493W86/pfvgmw8KnxXDRvNs5N8bPPb5YzXt4bNHL3a0m3umuf37nf/W+TUCbd9r9nWPfjqV6XPHBXZ02y2wnf/3rRNvjT6fz157x7Vu5blWrvq9fmcE5NeTv/bfT3jF5jqJ3WffhfZ1V79by2mSwnbdtnMbzbuRH9MxX47x8+Duj9pTPREYlDZfba7V3A3v3VD5PQv78EUP9/3Yb9F+bvD4wZU04E3m2cTd98nUeSbYe6G9XY9Ze7huE7q5Lz/+0l3w4QVu0PhBNc+x/PzzvDOPe/6D5wvHXYN7MGf40s9g/uh+quKccTO4fXvs6z4c+6HZhyPGVRcos/DWmLfc8Anta4r2Mqb+vWfp1n6PD0e4P4//s/nZZ5941n354tRaTtrNmnt9V9fVP0P6NgTvuPOCO7sb348rpynzPuuFAOkZ35zRv9NX33xlujD4+fJR7amWGocPP7zyWfrn8JcOj87XZses+DThZ99yw1+cKvOahclvTfZzdOQ3I92FL11Y+GzBLjPu4nou3tM9+/mzfv6vNc9a7uYuN5dex3t138uv4Uv/Wc0BIs997OvHkvcb+MjA9Pu5yW7Hbjt6+RZTyhiv/Xrs5/752j/dpeMvrfl72xTZCkK5qiHy5fmH2RGe97/TciYXMv9EPnf7tptzszg3YkTxOi6LSZMmNT+b5p133nGLLLKIe/TRR9266071Zx9//PHugQcecI8//njV9Z9//rlbZZVV3KBBg9w222zjf3fAAQe4Tz75JBnAimWELwGWkZ49e3plqNnZNHT+lltu6UZNHOX+8c9/uHUXXbeG+AXz5dKXLl2oXOy2/G7eV2oFfKWAhoolYsM/bViTacCJwqpwGbZHriUdEaFWb8T577b+ndtume3cu1+8a9br4fRK/3AaOPG+YrI2Fs/9+9zvPnrhI/dO93dc/7v6RwmmOEnS/0VmwvvfvN9tNXSr6N+ljQLS1frd0a9ubgosUsJG+uQ7T/p0QciqeIa+N9eevenZPhBXcMFjF3i/uigkqWBCTjicqE++/+To2ELzLsGfmFSlXbTjsOGHlX4//YwzNz3Tl0DQ70Ia+diPx7qn3n2q8rd6wPhi3WNsw/E4ZNVD3AGrHlAz/zWwGJF2L5CMC2KZ9r5l78Lri9axzP35Z5/fvF/Vu3SZwV2y1SXujTFvmBuHfjbvKmOWA6w3EMEVzXGx2AkZ4QnrnuDOfezcUpl5vEc4lypZSrPMUTMe9dSR0v0Re6dj1j7GdN/oeSLEXLSRNXXSyJNcIwjfOUe+p+7F+kRm4iL//bO/N8d1nUXWiT5nxin3oO9j4z5ggwFu+W7LmzKSd2Cddp25q5dPx917XKm2Y82TvXBa8Ix069atMJumlDKCmwbLxI033uh23HHHyu/3339/r2AMGzas6nqsIauttpqbccapZvbJkydX3DsEvS611FLfG9KzFHTKXRniKL3g8eu/P+l9d8GjU6vJ6jQu/QwrbVhXD7XSZ/EjYipuNBhR0lSt1MZ6ilQhxPr17Ocu2vciN+GrCW7ggwN9fZuwr2RDRjDBK6Kr2moUpbtp4qZcMqhU1oku8KcDCWmnRcyVWwAx1lex1FjeKVaUrBkF/2osL1OK4oFG7q9TlCmetudNe5a6V5humMrysK4XlCUVi4Hg9q2X2NpdfcvV7tCXD80qJEe8TE6Qo05vLepzqTBLPA3ZNmSb4O4sUnyEGCwMJA7J6iBwI5ZEy69wvpcprGi9kyZu04ilrzdCeidgzsDwvP1y21fNKZ0tuesKu3oOmhwQ70SMS8wtL++I7LbmX5jKu5hRzLKKhFFdb6GsPEC24OLP3Qu/F6m9s8wyi1tjjTXcvffeW1FGUC74uX//WvKV3r17u9Gjq819AwYM8BaT3/3ud97a8X1EyCgJwiyAw28/3LO1aljmWLIAFphjgarNgxQ6CebTabFWpkGM5dA6ZZfh0EgpLtoPGgoD2lU2aIrNFTPisZ8d60a+NdKnlll9FZaUDxep5juI6dBhNHhOW3kOAcBkSlmlxWNl3RH8oeKgsyJiz04pPlZqLGNNMJvMiVBw1xvEZimDVW1pm+zfGzrpeoS/bJbMccasHoUmDOY1U8xdF39dEWU5mQlFqc45kAwH3Cmc1rW1yno2P+cEOdI2nd4ao9DXc+WJd56oKuVw0gYnuVUXWrXyO43KGE8Jj9BzySqgiSISsi9TdVofmMgeEoXFAsGhKXp5FBwrKzFWbymnKOBhaxzmDzsx0AfEY/S/o39Fvlgp1cSShYoTSkwoN8me0vF11jhROA8ro1UOAtnTZ0q6Nn1AoK9FJGel/oZKr3DOwCViydlYvTCsVmVcvd+L1F7SerGErLnmmp5bhNTeL7/80mfXgP3228+7coj7mG222dxKK61U9fl55pnHfw9//31BjMpaL16uGf5atX8zlZ5pCadYtkUoICqTK5icuW4Yi5qc94LieOYZZ46yJ7KACJK6a+xU1j8Ej7StrFDnfpBSlQnqlUX38b8/rmQ4pNxf1mZg1W2xBCbCgDS5Y+8+tube3NcH6RmBhKmaMLGaMQj4mOLD9bRHn3BFeMIUiqAKrWWkTFvvWLE2GXMgfMeF51rY/evzf5n9k9OHAFP8g289WHkmp2855ZetuSKgtobOtLA2KZ5HJstX//mqiodDQ3NyNIJQ2cXM33e5vhVeoXEfj/M8MFJzBvD+F/zjguR9GStkjZ67jDN0AilLgFSu1kGrkGhpSgGLI0QKf2JRYXxjm7+wL+s26U0bJVNn7+k5B1s0WUUa+vO+XIPiSdGyNrZ2pChgahyXmneprJgayUySTT1U9C1OHKs2kpWaGwIrM3OAWl/a2sQ9w/l60JQ+0hZkK+BY84HkkENaWK3HapX5RZ99t/h3vozEf0Vq7+677+7OP/98d9ppp7lVV13Vu2LuvPPOSlDr22+/7d5991333wjrdCBUzeE1Oaec2AlNp+1hgbB4FjTNtlVmu+jZgMlO/IKlYTORmfRo+jFQl8NK/wvLufNd0zibbWJDbMunhNeLjpTVWCaTZiKUKpcaYVt1WhttOm+L8yoCU04lOrLeZz6sdrC79ZVba57ps3qW36XqdyhsQCoTsymEdO4IHzZpKwqe62kPCksY4c97C7V6WKo9ZuGigqdFTx/CUkR4vijTOem/D7z1wNQNz02ucEXUY7kRoITplG0r3Zt2clqVcu1cq6m1oag/bsRxdbdBp0PHLB9jPxrrM18YC9wxmNp1peyc9YtyEMKi0C8C76oVESqNW5uZpO3TvygGuRV6JTUbhLJQ/g1tO/VnLPB57quVQ1GQZG5bMkbWTriew3WCIo+bJQfeavH478y/IUvCCrr1VKDWfYPixtrW94zhsgLLhpQSaUTZ5x5atmLlC+nopxdadPDKTxbzKWua5By/c6yAm8YBtxxQVSWYzVxKNzcjBgCyMtrNaT9GHS5+XMtHGUMYjxHSlN/w4g3miZ+o7Qt3v9AtdclSTc0CCN8nBhQ+TViXKvwlPv6R40bWxLaEZGlnPXRWzd/l5KZPpLqonli88PHrQn4nb3CyG7j5wMJ5ViZuh+feuuetdRGbhfTgqfGNgfLk9HeZOZZTliBVD6VsmYUyQHllkyWl+O1Rb7v9dtzPx0FZ7ydtBjnvb8UCNEMW5FSG9qnlFCecYpFLFW8ril1LvY8gNr9lbotL9u2P33ZX3n2lO2irg9x6vdaragNrOFZ+oky2UazoIyDGib7Tlq6ckh+p50tcUAr3Zewz0u5YLIrG6Ruf7t774j13xTNXFMYUWcUSv7d08P+rYAJak0iompmMRSZr8YNyookxgrIxakUE8DNskSgwjZwkBQRf4fNEGKTKgIs1QNfDALHUR31S0qXPWTz0DYvsFyN+UeMXJX2Ma9mQw+q7ZQVJGBhcZIFKud4scC8sAkUBh89NeM52cRmslT6d9t6T/CapT636mrMfPtubgeUEZvWDsM3ylTNH+DyKiA5GzMXX//naFxvTwpg6GGVw1air3EkbnhQNiM6FNktjwqYfY+cobzubRmcs5i7jJwomZm1o92Np5rSZ9Z6zMVqxAGIhkErR9YDPwUqLHIttoPyeoHE2t6IKvVX1qRJrNRXbYLkWhUV486s3r1Hm/3jVH308zBZLblGJ5RPZE0ufzoWMkw5Qt2KqxEVaVPKjiCAPtmfdF+KK/2KKy4z3yimgKu2OyQrdHvhK5L04qKaCc2lHR6BlGQkiiI+7+7hoFoloi6FmjCuE4CT8qyk/qOC0+04zyWxO3+h098tNf2mehsqkCsdOZ0XWgNRJQ9oQxixYGz0Q4Skpor0/7l3pZ/zcRWyhR619lPvt478128DGJv2deh9Z5LGy9SkFpuhkUm+aY46i9fbRb5sWgNDSIv/OgRSkq5f6XSw7sWyK1HulMo+u+PEVnsUyZl2q/Oxm8O4mlCJSF1Mn8ukJiQGKUc7HrGcpXLjVhV6pj2UPVbIq4EVZfmf3t5f/lrx/KAOsDTS32GQ9VppQdqaKbeZk62i5GlqY60Fulk6sj8L9IOZKDtsPQvdKF9fFHbr6oe7yZy8v7ocpa2KJeZaIzj9LThRZDnF5H7XOUW5679/1Ob/+h2FRmYvvVCwAulw8KVu/2eo33qJR5AcV9Jijh/nsheZcyH9HQw8nCoFPZCaUBQsE0zqFp0K9U/vVxQ+MsE+xler3sWJsJOBUNmpvEbjvJE82pc3/0DCnEFNEWEQoi8TRjBg7Inp6k3gbi8FSThRWPwjktGFBYnHqQdGmxN/3uak97gRhi2KCWZfsJ28NmPL5Smp45hLmnTmh12tx43lYBazPo0SnxlMyj4hd0DEAxNdYigjYcsktq+ICuEZiMb4viogO8oy9f5EiYs0x3GC8JwejkA5erD7CMQLZIkqinx8WVf8Uin4gazyMu8ixLoJ6LLY67sSsd9PW7rZAnvaaJ0/RETlz+6u3JxUR6Y/UGpF3z4nNCeWGgHWKMoMSeUnf9rpARe3nsGbFebS5Nl9RN8f9KmsipoiwLtkzLKsRqcgx+UbxvY5AyzKiLCPalx/6TkGRqT/lB9U+OJ5DTZsQ448e77/H/M+pE1jZEy4pevqEgrVBiosVcaogPEj3LPIZW2Rk+H3LxqmA2IljtxV2c3/dbarJMZefQbgNwih0ibVBYFuWCeknUJZrpYwlhRO1rogam1spC1LYVynrxfbLbh+tg9HIfVOWrdRJVOKu3vzkTTNNtZmo1+qoYy1yS7iHz9XZFbFrctIz2cwHjBxQszlr/h4rHkWnsoZ0BiHKrtsw7iQlHwkATsUBWfjxsj92t75aG1hu8bCQ4UQ2i76/LqiYa/UhhkoC3qtiv9QhNCdtvhF0yYiJyolXQsZgydcZk1DwX71z/bXNGtm/W8rIFGXkd0/+rsq9glmZDUnS9UKiphi5UTjw2uyuEW50BC/iDx3zwZhobQ8WLXEFYZZLPTDjEQJeD4I4w40gXAhlFp64eYiLKEs+ddpGp7lfP/jrZJBkKqhOt0vagYUrJoAkoFj6AYRp2jlEeDnttxDOm2YRm8WAYJpntnkK01/Jzmm0qCBrZ+guQwsVWYR+36X7NoWoLNUWOWwUBSWC0E1y1qZnVWj1631+KtU7FxwQimKcUm6G3JiqmBtb3Gr0CRYwuE7m6zqfdyFILMR1o6+riRebFpWjwzlExqKV9i4yQJQwS5nLIUAsAnP4zrF31rgdi4KK64VWApEbx951rBkjIoR0WM0ffPNBT9t/1G5HdRjpWUsZGT7cjZl3TA21uZx4UsLZsnjkKiNluQ9yLCOUD6dqpxWAlYswshyyHqqgpvyh8iw+e9BqB/mUtHrfwzql8twrd7jSHTisncvGOtVDQBfjIbEWfs6GiJKDQmqR4IWnSx8rpDJjyrxzDGKBkuf6TaOBQEbBPivv4/48+s/mqW+Plfbw73PPG/e4gQ9V1+Sgb0/e8OSa39cD3q3I4tEsxk1ZG5c8cUkVB4a4VrXCh+LJWEN9HwJXyBoLr+Ge+tdT7l+f/cvN/f7cbpEVFymkjy9C2ewoa36fstEpZhxajswqyrbTcz/FjPqHZ/8QzT5LWZ9isgryssXnXtydPPLkupW9VLKBVizLWMc4WJz50Jl1z0lRFj766qNkMH+XSL+kFBmdyZnDPSKZPWXYyMuilU2TCVjnONnE+C1ik9PKwbf4BPgZIq0LtrqgxoqSq4gwKcWvmVosBLMdv/7xXqB+MOkDzzBYD6+HFVmOSZMJHtu8mdTCHnn5M5dH2yk+9pBlUJvvWUQ6gIvNN6aIAHzHYSyFFkbHrHNMzWmOdrz4/otJYfXI+Efc8xOeT54aJaofAb/Y3HY8w9HrHu0tN2VAf8hmrQPeGlVEmLfQYFvKCPMRZYR3kQ1LFA8JrCMGIgdiXcREHp7YhWm0KEtE5kpI4JUyUVsCHFfe/23zfz6jSNK7rbT7otMu2VNYLavu304eWjdEjkjWTJGrwrtZt5xKiifvm6OIWDKLYOBYTFUoA8RFaWXnweCZspil3in2N+TI60e+7hZ4bwHXdbmu7pOvP/HpqWUsjCn5p7Ouyig7ZZ5vKQsobsw/4SKK4eQNTzZjjshOw+JkrR1+Zs3kco8gYz77+jNfUbmj0emVESqHxiZiNDtABYVpxFKs8Ffe+NKNVTVXygSD/WXXv1SYLGObpwiaUIDErpe0vHAyCz1wGGiGdUSIuCyFi3Q13pPAKBSN2CYj6cFsdphItQuEttcTE5O8vs15BefCx2pNtUVChXZq83EsVVHw1iftdVzC9yUO5bKniqmZ9We4Vj+X/izIGCyEbBwEKcfo3yV9FoUQl6AGgXW5EIpri0BJNgCUurlmnSuZvYWFhnbIfEYxgeeD+k5WrExolSRdHiVdWyFj8RNFwrtR91QOMWIqZRmwpiQFN7feTSxIlTE++LaDzeuJ1QllAAo964i+k+fze4qzxe7TCHg2xd+o2jv4lsFVFozphWZz1oiyAIpoIuaffX5zbFkPjAFKSWilLFuyQ2TL7DPO7qtMdyQ6fTYNJcxzGfV8+eY1DvebAgtTM0MCFjqnh9igY5JLMR6mKOXl/hYTphVkq6PVMS/vtNxOVUySKAwEcfI+IUOoFVkudSHQ1i1QFwcLEFkud75+p6fntgQHbULpkPdByRICoLIBbNwfEqpUP7L4EaxYR4oYRMOYEZQyqx/ITgo3WX4mLTHELivs4hWsMx46w2x/2CbP+Lr6wbWKAv9FlMocoJAJ46PwvVj3kqyxcGMuqyDS5ylroWQliGJkgesQtno+w9Vy/QvXR1kz9Vplrg56apBfc5qBle/MNZRn3pUv/p0Kpp0maHMVqnurzzVbsGVJwfpZNC60XbJVQuWLPoiBLCerP0QhZww4VaMMbX/d9lmva833FLgWRWfQ+EHVMm06gTWDi524CjJlUu+110p7VcnS1LXQJ2gma2t+zaio72MKRHhYALgfNR9WDpAtuBoPeekQXym5o9DplRG0bn0SEXO0hUPWaC8+ZKXuSnroxotXly23wOcQqmwIqcUp7pmwXoWkFVM9lEWCxYLfW9owEw3T8s2v3FxZyOTzcz1KAT5e+cwJ65/gfy8FxUIQYJcTLwDZGrTCluCQ9GBSFiHUkg0hlzJb983jBz/uGU1TVOXi7kB55D2xUhQB5Y3gVSmIZvVDqIjGTiJYxGLvRTooY6f7mmthSQz7H4FlbdqwqxYJHT6LmxBICjPWhfB+nABT71IPLKGo3QUWBX8KKINCOpYC814sKhZ0qjBfKNIhaBNzAS6HaQHaKEpZrOYOKc4aUh+KuRcLdBdIbIzmLBHALFqP60SPQZk5whxgnJFdBJXq8eZvKP8heNcvv/nSbEt4iOJQgkwc1HdQlDuDmCjZ+PmeKmFB+8S1LoemlNI89IWh3nKW0yfMO5EfyFsOhb9Y7xcm9T2uRQuxwwlWMxAWExVLeAodTQffqZWRJ9950mvdoWmXk6lV/2KzJTYzT8qc0oTX4sfX/Tjr2Xyu19y93NCdh/qAqJh7Rk4zIRfG31/9u3chSD0O6m8Iq2GIGp/jvSd5ZSC0RFBk6yc3pFMumwHePazjgaWojAmWlEjx+2sFDYEji1oEjz5VoRykNm8+SxHBIibCkEPG2nTF3RID40/9FkuBRCHWwpZNJQR/J2sB91/RhiRVc8UyR2ByzE3TSP0NaRfWPFEytdKtK7VK3wmfCht/4b3JdMmYm7nXWQHZ+m/UvMESNi1gFVUM32HEG1P5eQBpwMI9UgTmEdY6rTRX0IC3I7dvY1Ygsluq+rytumKvftc5ZpmjRi7QbwTsYrGQGi8o12y+bMaW8kutGjZ8Nn7hh+LAoeVG+Byx4DYL2jUq8oOxZC38fO2f19TBYX1QDbgMsOZa9dP4N5bCIstUjEtleqDTxozE6ltos36Yl05MgOXjCytnlg1QtGiVtXsmZC20NhGJytZxIrEURSacDvrUuOGlasHb7Bx5QbhQUJCwFOTyNSCo4OHQtNkSSCoZIS9PfLnm9GhVI65wMbgZvHVISpoX+XT1wpVNV/PTsOmmTvExfz/tEQucZ7Dd/GwvZGPKg5yGrPvwvrQBaEHIhhCrOJwbTKlPqdJeOdXp2CUdzHrvuHsrLJs6doNnLtdtucJn5TCOMo57rrSnu/aFa12joJ1Y+qYFfrT0j6rmL6dgnVq6xVJb1KTxi7s0VxkI45zY/FCA4RkqA5krjC9rhINLPVYgq1gmf7MCo3nXSd9OcpvMu4m77+P7zOrhIVcQ7dSlD6zyF2FVdNY5m7hlwZV+K2u5tRArVhiLY3qtDgsl8Sixz9HHUqGc97U4fGLFEacHOmVqb4qzIRWwxEAd0ecId/ETFzf0/BhFb1hvRbTjsvwS3AurCsKfGA4LO/Xeyd085uas++WUj89FisNBMnJuf+V2H4NShLCoVhicZ22mVlqcmS6pMlhiXCLci8wGi59GNvWiom7WPcPTeizFVdL4rGKIOeCkKPVKwjmHGT/k1sktNwByyxnoNFIU5KL4A64/cYMTTXchz9hosY3cQ+NrrU3TA/WQpwm5nbXOYynp9aSJs1aoE1QvdbrOpskpzJaaJ9bciCnlN+12k9v5hp1r1oNOPbb6jXWRKhdRdMALZUzuemgEMwY8MPWQzBURnYXPCKnssU4e2qfY6lYGLTr4BGKaowiT1En4k39/0pQ2WEF91+1yXU1p6Xq0Y+71xDvtHBmk5Fq4ZcwtWfdig0WbTgXxYeKEkwO/LMI1du3FW1/shUTMHYOWDjHSpP9MKmwX9yC2QrsecFXhyhIztrXxQeNu+eYtq4OcjGKmXJQqLDk6hggLjxaAjCOxLTmg/4hPsE5QCNYwNobno6BghUi5aixwH8s0LFT6uNCK5p3OBhGrlJwic/o4tC69+uGrhe3mesgBvf9/ijleWxYfePuBZLst92vZDA3md8wdWvb0jFKFZTUW78V8tWIJrADkFG56+aaGarhIRh3IKeKWmifMY93n3DsW7B4qIpZF0uo3SL4kPV27t32w8gt/rQ30N0B/k80l64Fzu3adEnPSzOye7wIXCX1FccCcgGBtAfLxIglqBf0McXGP2HuEu2yFy9yBq8YpFKY1WpYRJWCoK1AUFFaEXLeGZSIXrVaf9NlY64nhyCmixMmYFMmi9kJTHytOtt2y27nB2w6u4VAhjkZO3Za1oWzmjHw+px9iYyCWlzJWBE0SlWulComlypQDBykSKms+yFjnUvNLHAnBv4Iy1pCQXCkESmFRZebwpE98zlufvpXkk7FOxRZLcArMgQXmWMCbqeXkDJivwtSpraNSQyc0+3/wxQc1RImNzFmC0UMWUj0nJI2W7COREbi8JEhX3Ce82xsfv1FjvS0rl2IWzBRZHSzStCd8Du9Gf0tlWqt4pbYM57SReBGZA7HyGZq0Utw3xGDkypBdlt+lxkWnKeblXXB3vPD+C6X5R2J7wKJKlsZkh2aQ1QVQi2RUjISzRXrWQRDtPCTuYWCPHH5kQ77B3Jx/fN86PgOBF/rZrcWTK1QQJGxO3MdaVHIy5mvggwOTHAoI6lgWCqb14a8Nr/J30r+cXPmMFjpibbCCMXOQu+HEzJNC567HPlVlM/Sf5lipLJ9rLPZEM9dqv7Y1N+VvVto1Yz1y3MjsjU/HkaCQ5DA1amgGU4uh00pxtiAbfUrZXmGBFdwrH7wS9f/DUJvbbj0HQjBfWQva1aT/DaU3Cop8fsRrI7IVLVF6hjw1JJqNRuA7QdnXPHeNHx/6WN41dCkAH+MUuAUBY7HwXAvXKCO5igj8MLSXeWa5zF77KL4Gzn3kXB/3JUzEvMO+P9y3RsmKcRVhGWb+FNHi6/Oz0ClYpIZh0dKyliErVoj3wuocEhKSaWmxssbktShLEmM2Q4K7ylrXZ256pufoAfrgUySjhFohRvffkeiUlhHBuA/HuWvvuNbtvc3ebon5l/C/oz5BTvpqrECZhZxS2Tm1CuQ0SrVai6469Tmiza974bqqIMPcmJQc6vQyWn0zY1BSCDf7WJEwFmcYFxJ+JsdykKrrYcWOkI7IRoLgx0UBYZxYGnT7NC03JzHL0pWKpUgBt1oqBTbVt37znKIsy7vn1B1iPuJ+KCqWJ+On4xVCinKQiv8CsTmQg1ARwD2CAofsWOqSpZKbvNQ30thu6Ha+dEEOPXlWQcEpVoIi9ljef+NeG7uRb47MmrupE3nqnbGcYDUgyJbxya05k7IMpqyPzIXbxtzmU1KnV6xPzKJhyRHBxott7B4e/7AZn6WtcjMYMkTHdVj9jxwRK2euPA9ltbUXNgut2jQZCE1T1gnRmqhla2YM3Gyg5wuQE1LM5ZEDFiGkOdbnizb5UKjnuhBya4nk1L0oW722EYhJNXYa1tAMnXrTAbGTaYi9V967QjqUW9MjtJBttdRW7sofX1kTjKstZsRMWMUS68l8ama2VE5wJXExpFnyfrlzTyvimp5f5nP3ObtXnTBR6h58+8FCRaZoTsQEu7ei9Pm5O/qao93g8YOj87nRgMTc8SHokBTk1NqEEj/FecM9yGZKzdeybS5qu3YJoZxKNewzHzizkO2XGDU9F1L3z5EPjchkLftwo8YOC9pKliqAOWOkCGuKcVdXE84p4KlldZlCifWgFcBaEhYDIpOV4EN8c1YQWRiIFcMpI0/xigtlstGeY5O+iNtBXAAWa6WYWBEqKXIe0pWvHnV1hWwsh1NCXBkpkjbLPREyxko2kgXajcAsC96VIF2KaoVgk8CHrhe+JlqL1QmSVGMhswuD3XgmxeZCXDv6Wr/ZbHvttlWBtSx2y3zq2VyDVGqUDE2oFj6f7/eMvSeLTyYHVvAgP6N8as6WnHmua8nEAGuojEdZlkiEPNYlPRaY5wkiJl4CYSxBrNIXOvBSgnP1uKQQM3nzPDiKtpx/S/d6/9crm4DVH8LWy1eZkgCCnOvf/eLdQqWhKB0aZUb3ixVoWrbNqecxr4btMazd/TuF0VoI6HLKDoR09db9Q36bXZfftTLfRAGSgwoyNXcuWrwnIvti9cOYC7T5/S/e94qPyJ+YXHg94PoQl2SsT5FfmrcHxSdGmEb7JZXZki+aP2l6oqWMTEEsKhvhqkm1GGRM0QwWv0ezzgH3RpCmKJhZHKmsFcmv5wvfrI7sRnBwUkCopIQAf8PFI2RjKEdaYeD58HDoTYjPcD0THhdTSC5m1b0QeGbYI19zZyx1hvdzUlXYwvxd5/cntzIQC8ZvtvqNG7DRgCTTJwKW99VEa7IZxQQCefm3vXKbOS9W77G62Sb6avjrw2sWd4zV1oIWCDlZFo0gttkgpNlkZd5f2tceNw3mDkIOi5KlHAJcQiLomC+xLKBYdoU1t/kdvBexYGzGklNlWaEbyxrhGRtetaEb8eEI/w4pVl/iH2STtUoCaNSz8fMZgsiL5laRsmL1CzF0wsrbTEisEHEyZL1o5TI3toXrUooI8kjPXyyWN425qUaRZVyOu7vdApqbkbb5EptHZZ/UJwvB75A7ofwpYijWiDFCA95LFBisvBx+Y4RpvDt/Tx2SOoL4rKWMFAy0aJBMNiwbDKI+QZTRqFOLTQJKMUXH7nf1c1d7IcFztUsBBQHBkVPbImxPmL4KM+Gd+97pf+Z07At3KbIsSV2Vhc41xJMIu6IF+o4aQChB1vuziY1+f3Rdp0bM87rOg8X0abHN8m/qO/C32Al98FODfXaVdRKK1Y0oshiUoT3nVE3GRGyuSOHCRnDoGrUp0PwswkhSdqn0az3LSjUmm2azxTczr2cO6do+McI2rGRla8LE5k9YeDBH6Iq1LAbeFRfNBY9d4C02Re1KzW36Cb8/FtjYO1t9ybV8Rqy0KeW0DKOuzD2rom+joM237HGL3yjrdQ+yjmI1jaQqrnYzYI0I6eu19UbqjOH+zsE94+7xfYRFNqz5Y5U3kANdKH+QvSCUW78PDnbCvn3ls3FLnigwrD1dhymG1CGpo4jPWsrIFMSovwnEssz1MpggVuwoF3oCpuoRMIEhBAvdBigIluDgb0XWFhHImidC14qJCXAfePXY7yrFsorM3rdNrLUw6IWaUwI9tilI0TRtwfKR6vee6BXHWAyD5ulICXPtygjddDnjzmLnlJ3LLltUC0jiUsZ9Mq5ugS4bYJFFqUjI4h7Rn2eMSev1vAyRtkltHwTnmIljzGv8idk1p0or7XjuvedMuvWY0C2q3QJoHy7YRmJueD/qC6GUodBzGIhZlbT1ko2Qa2UjlLlvfTZ0WeSAMdrjxj0K+7/s+NBnudxJvOchqx5SVU+GOctBKFaUlPuLzC7DmaNZicP3i70j11uQ8gYc1PiKWc9Flmq59eZRb/p5INwo2rVIHTELIpNATIE+Ys1a97jFX5Syck9rtJSRKYidjsXMesYDZ0Q3ZiZTisyrCFK4DhTVI7D8wxJlbW0qmJCpoBsDn9ECWU9+M0jWtW+s9IkUnysye/O7YROHRbMHoifaLjO4K7a/wmd8pACfiTb98z5hDEgM0m6xDvVb02Z+lXtsvdTWVW661OYhgLgop7hbLj7/+nP//A+//LDue9D3ZFhZFiURRmE9pNBsz/uc8/A5hYI+VnkUpSUnC6LMJhpz7+DGsZT1aP2RzKXcaDA2bSDjRKytPqZsxdp1J6mvYr3ENWltGJc/c7mpvGqXRW5slszXVP/rOZ1DIIf8mG2m2bIsNaQF4x6EjAtSLt5bc+MQ8JqS2Tq+KAcWyRwKeEyZ0AehELoiOWVEUm5NuX6TxTepqiHV86Kehe8g1bhZm8TCmZbnLjO4A1Y9IHro0K50vndU2m9LGZkCKaseCwyk9kZqMhELES7M7ZZpL7hWBAmWBCnTKG2z/MO0g3S6cFMRDoeUwOedZeMZ/MTgwskvrKMx37xl9o6ZwlmosWcR0ErKIousqI5G+NxYH8YEpf78ygusnHwW8SBhoN+Q7YZUMYIK5CSHj7mZ5m7IlXj+qAmjsq433SVuso+jQNnQbjqJicLvnBOE6/kkCjaWQ1Y/JFmCPQXmGcp07ud511jhSeveMQVayMVS2HXBqQGRjSAnvkg4UsR6KdAKY8ziIK4w2fD+uttffTbK6RufXth+UYI44aeulWB/LAKpseJ+uD41mymfPWz1w2ru74sCvvOke/frd91S8y5VFYjOO4OYRTM3/sRyf+JGwjr9601/7ddGai5gHYnFHUnAfIx3RyyzsWB1kMxGmlKNWxQYq/I0kHo0KQsI31eea+UOsYgIWsrIFOg4jFwwmaj9ssGVG9QQ6jCJdllhl6z7yGZIG1KZNkwmyz0gkxroTcUiTLNMnmw8nCRQWnIWcMo3j981XJxo31bGBgs+piD0XqB34SLT99KBqrE+xBxuZRuxMLH28KxcvoLQEuQrgk6pIoqglxMsJ7myVXBzLGw8Hzp8q1+3nm9qADJjoisA6+twsekTuY6J0n7nok2yyAVAO8vE2IQgKJssnKx+cZNdjzl7lIrnsZTlosBU2vKjbj9yg7cZXLeL1vpcGdN5mB3EHC5yuclGTj2jX27yy8KgTVGCODik3JL0+9PvPO0VIsY6ldFX+d7WThnAOtl9pVpXCn1BoPCpY091S1+6tH/f8J1BPbFTXL/9MttXJQHQx/BMQfaG7MQFJ0H+sbIaOnBUI9dFVBSsnsIx67WTw8WyirSMF+g1/X1DSxmJaKRl8Mg/HzF/Tx0b0smKwELAwpIqC379LtdXfIkf//vjGoVAx7Bw+rGYOvkMJkcEAPThmOkl4KlRF4LOugnjRxCiR/Q8omrDEvM07LBWf9D+3DER14GMYwxspof3ObwqVVsq9ZZVRGO1JOh7FEZ9gg1dIUXIHYvQRcAYDOk7xPVbrJ83t3oh1MX5VMnwJBoKJixiqf5ObZLaBWC5rPRn69m4aRNulrBfYm4BTt65Y5kK1oul7ALawomdWh6spTKgD1iDVrC6Np2HdYP0aXvwk4NrYtiwsGrFMGT1tFKbYwHElhJEG07aMF4rheKW3BuFFkK8IgWB+cv7vPv5u27ilxNtd56b+n4EnFtxe2Vjp6Rdt712m18XEoi6SvdVzEMlz8QdEgvgDudP2f1E5MhTJWv+oCzHFBj4fLRbS9qklcGOSuGNodMrIx9884Gn/Z0WmuL6Pdd3N/zkhsKYB9wplvKgJzx1O0SQxJQHvTnGJjbuJAk6RevPrSESK9AkJtYw6yac6HAyPLj/gzXBjlQO9sX11AlF0v6s/rACsbgOl0PqZCEKn7gl8KN7UiQ3OcpAmsv7EoM2oUvufzMLa4HQNQi5nkBYHcOTqFWML5UqmbNJiiKWCoildH0zCO94TyxcuASsDJTcjakoWA+lMhZfwWfJEGNsR75hs5qmYiGwNGCdOGadqTEKvAfxY1qJFWIqFJDDbz+8kp5uKVysf5QLxkUUUckU4dBhbeSxlPPD1zi8JlOEd2WtFIF742LBEonL7KxNz4rOe+I7sC5nBZnyn/HOUOiXgXbhaB4a5mfsfVCmwwBuXQBQIyWHGGPLMjvHzHNkl1EQUMQvlhosxIKpNnVUCm8MnbI2jeCPo/7oDn/pcNf2Ujrtrh6rAVTQUruDmIEdltvBZwhc+OiFNQKZhXtknyNNxkBJUc05uYvQT9UHeeCtByr/rue9dB0foStnoodERTpLRwDpj7UgYBQ9fM3D/fUsSk5WsRTglRZcyewnFCxMztbf+NwWS2xRYcwNWVStZ2nGRBRF2oargIBNq05KCIvVkFiMZgWxWmBePfavx9zYz8e6L//5pRnfAQkcY1aGkl+ELkC5QgBqpl2BmJo5nQsjqvQTp99GqsZq0Ie48eh7NktqdJRlz2STJP7KKvSnxxCysFAWMJ8GbjLQPfv6s+6QS+yCjym5wXpnHus1zfWMD+uWGClRAqwyAjnKsVZE+c54hHJHLFa4S/XYYM0dvN1g/2/NWFvGjcC9hQq+Xhma+7nbX7vdNQKRVTD3poL8mfPIPQ4+IGR21iUbwvUlbK8cKom50/dmfXyROIzG8MqHr/jnh+MnfFRFNW5oE89lTS/+g8VdR6PTKiNMnH539CtkCSSYiQn24VcfZtX9OHrto737AyFnbUhWdVVtxtYF3IQiObdAm2yOTK5p5RMkmI1THdAT3qrXoK0GEEQNGjWo5n6SXilkbrG2i2AS3o9QUGkztaYGx1Jw9xt3u7vemJo1kcre8WM1xbzNyTVc1KI0aUrnELE0cJSbZtTloX3UoTnnkepMFs8Me8s+7RvA2No+EuFDSnapKhBtzrsGhbY6Vj9D07QTp7L5kptXBHYsDVLj9I1Od9suu61PzUwVSwvnlnD9lOlXgoApbBajvk4FE7Kpn3TfScm5lJIrYRG3qnur7C5QRhFJrX9Jk9b3khN5mL2HtZL3Dwt3xpT9GHKy2XLeK6eSb4hSyraSQRwi9cZOnzFHtLVK5J9GKOtREMJKz6wFDk1V/dHWnqV23ehyrj6A9cPKvuS5Z252ZpV8CguEypyQYoi0ud+i/Vxf19d1FDqtmya2wWs+CTRMtHvheygysVPZE3IoNrHYhrTEPEtk+Yl1+h6KSuzZwjmgTaoxFsBcCHWy9XsWVIhUeiigLwaNHxTl+mBzFJeOZXYMU4Bjwk2bqelDX1Rw3IhsYQ6dfmjeDrlTtOlcp71qxEyiWIZCttuy4yS+4IGbD6y5l7UBhKRkCB/ercwGIVV+Y2ncFmU+ljIEr6TOxk6dAvrh4DUObneNrLhb1EVmWaTKxuRU3iuRjp5T/bTeTdbXZ0rcW07qwvWTo8Sh6M41y1w+lmTMB2Oi/RcGbFon8hhjbRiTwnc277DfyxC3pcC7X7PjNe7AhQ8s9Tmew1qWYPJUiQx5DsoA65lNXDKNxBWo43X0mpefrxp1VVUWIt9xHTEm2p0Zy0ajr08s6aJZs8ea3rJXxv0iruJYqj0kfh0ZQ9JpLSMxxlX8nPxN3AW5aVaS9skXg40vOLYh8Tf8lLGy6FrQHnDLAUnzNgFlLCArTblMPAgCZNiew/y7yylBF4+LlbgGTGBcEFYhKMDCSPUdm+OFj11YOaVqDZ7+4blhiXBvLo9YY4qsLEB4WfQYoERqSnEfNHf7of7kkipcF56uY2W/2Zy5FuGEAOI5UPjnVtoNfcE8k6A7LAlwN2A1stJifSplA6dTa/PUbjiUSaufJejwm+++8XT/2y6zbbRiLQGPYcCvngO4KlFUYhYp+kJM6EUFHWPvoeczAZXNLCIoEAtDWLU7vEYsPzlt+E/bf0xiv/CzOm5ILFa8q7WOYoSHouxr6yDyB74NWTuWFQZsusSmbuS4/Pga7oFrdPk5li9t+dJWTebNzDPOXGV1DuNGRFbKeibTSCscT7/79FRZOMXyEWYratAHuOVJ+S+SC7AsTy5pLeWgCpDXlsUrFsuWcgfR5rEfj2161d5cdNqqvbGKoVLNkHoF4QZYBnKaD83oYYlwXUE3BFTlBHelICXEQViNVCsTObCq7sJEed+b93melaKKtrGKjznl1sNqlTxbBB6wKlt6ltUgNiEMuItVSUVI7LHSHlVCFdIgK/YA4S2mWeueMgahwnLwbQeb70i7NZ1/GTM8Gy5jwkHv7U/frroPCIXSxdtcXKOklIGOWQqDZTk1gjKVaLEeorBbzwkrlTL/UbRIFU3FdmiUqQRsPdeq3N0o6KuBmw50S8+/dEUJKDpkjD96vL+uTMxILrD+6U1SV3nV8yynmixopMJviJjSseUSW7qRb47MdtmwZiksp+WhyJRY1fPwPbWbqh5Y/bXbX3fzCRMa1tpNAWUK6yjts+bGXivt5c7dcip/lMSxoIjwPVZtnvtS+LHZykju/t1pLSOWlqoDQKlu2wiYIFstuZWPeNbauDZlYx1BGYmVNY9Fd2twP04lErCmFQKEjt5wr3/h+ihhWahNx4SynCJQqrh3aMrlJMxpXYJ3eS+Co/brsZ+75r34SSI0L4b9EZ6URfGQ98OSxWKTOjVAKKMtpVLM4FV9niELIFSz0qo5kWtfsmcrNRSNMF4gJYAQqJDZibUJ4RPb+PmdZDnpPsJ03whgnJ1z5jnt1NbP341WKY3hjtfvcIP6DqpRkEILRb1lza1aPjGFj9+H7sRGNp/YRsqzB9w/oBJ7UMSyDFjTKAzMI9L6P/rqI/fchOfcZU9f1nBGEkH0fRbu42NtJAhYAtJlHcXWnBWwOXHSxKYpb5duc6lpycPdyniRzorFIQXh0AnnjlhMLWtQkZuqHoRzmueGiggoWj9dDAsXbqUYq/PQF4a66164zlsbLa4p6BSICwoVu43n3bhDSc86rTJCp0NYRG48izsMAGvGSWTE2BHe9fHVt1/5QnBh/RUmwxG3H+GjwcXtoIVukZ8doOSEkfMoBGQYiLCRCSbKCQuNFF+dWaMjsHOEMgthsbkXM32gaN6hGVMWlCyGm16+qUaoCvnY5le3M5bq/tACU5vq+R4G2uk+XHCOBc32U+eBL339eou1F98KLQBVcTKRafHC+y9URdfH/P0+ayKHO2XKc/WYFJ2Q+duJ653ovv7n1+6I7Y/wJxw+Z23GEtwrRb/4mYyvm1+52XQ9WsBqB6lSGRO6zIFUwLMVb6WV3BCyKaKIWC6vtRdZ22cZWdAFHoviRCRweNWFVq1xBYnFK6bs68DUnIB0XB7d5+he5RpgnuLqKJs5VNMWN9nfI9yorXUUumRiAcvNAPd554t3kkHBVPYumm/eATPF4K/7PeYGtPDaR+UIyCyEBzxv0awDbUYaPhbhIllgWd58H758o/vZWj/ze4B+x/s/vt8z3q7Xq5h9eFqg0wawAgiLpO6BDgAtQz6jOTdCSMAgCz9WCM4T70T4ORC8y867bPTZPJeMG0shiBWvYyGyyYVWFyKw5bmxGICqZ0wRQrFgKBaCFW/Dd7RygktRjnQwXJjCHPaHLuYniAUKS3HDVOXV8PqwGBzf+Vk/TxQWKztDypFzrxjrat9l+maxg9JPOggtN5hx4CMD3QVvXeBGvDHC/yzvJEGFtF2KrEl1Zgn2XWiuhVxZEPtA7Z0yIH5EE6DRJh2PZM0/YTve/YbdvfsG0M/0t/DvxGJvHv/X41l9XMSUS50UAoexgGnmVTnIoOjr2j2xk3IOI6+3QI443gyAz9n8c+rEhGvFWkdYv0JPvlTBzrHulWXdLSqYyTzQXDpgnUXWSb6rFdApwZwxEOeUavt6i66XJPAzU/+bSDE0ucEikhc/cbFp9YbxNlXwdFqiUysjoNss3dzGvaaap1IcHRYYQGpvFF2TC71wWPSvfvxqNIKejQQ3T2xSxrIFUhHYuS4qyayJVRhOQVKZMUNrAi2C46x2Uam4bOZKmWyEUFjJhmJtLMyT87Y8L1qQDZcQSglmVItq+87X76zJSIhlLulTVZkMKZ8CfccRVf2l+6F3t3aODnkfoYEf/FQ7t0QZ0PdlslgQ8BVLU5fqfhNyrlSsFiZ6lJL1r1y/plhjDNzfYobVtaUAGy9jEetnaOlFUFsHmSKLhw6wzsn+sVx8rBvM7yEgHiT7gy/ce0IIV/QMvVasdSTlAeRgwxf9nyvTUFRjzLwaubFTjJko2oIn/vVEIUWDFdAJc2sMBFunxuixfz7mfrb2z6IZbyFhHMBS3Swr0oxdZozKoUaVnI5iZu30ykiIsvUBWByx0s71gMmFgOTElwpeXWHBFbLuZ50KYqx9QmCWE2gqRFZFvu/UO4bWjtiJUWimQ0uPZD1Yn8G6VWYDpz0pK0tYw6jIREpcDZHpIcT/rtP+YOnVhfZi6asWA2Rs89TKZUgDjctDWxca8Y3z7NRpVp/QeS8EPLCeyc+Yn3Pw6D9rY3di4Lkww4bFDBG8ZKGgABFQynpD2YndN5wP4UEmZfGwqNUZ+1RROWuNWrwggFRqlCWyRrDcSCyIKPu37Xlbks481na9FrCGWEHZKUAS6GkLVkvH+2QpImQpRizBUeqDCEvqlIeaYEyxSqfGKFWxF+Zt63myhsumoIfQZRhQOlE+aXOz0FHMrC1lJDPl13LL8P3g1Q9uaqQ790Iopk6HtEHcMAfdelDpU4Gw9mlIzEiRCVm0foAgN6Oyp2ySqXeUapU6d19OjNFiXGozKCpExaaGskQAa45CQnss94BemGU37piSCm8Nz8MioeN5pNBeWItEU8qL8PG1TQ56zN005iZz/IXIKcZtwPPZhMkgatQ3HouNkRM6X0V8C7ptzTztaSWAPqbP9PwWxTGXHTYlqHmGZQ1jLFA+w5OyEGhZ74viZHH3JFMzDeVZlH2UGGucjl736EpcmcVbo1GPnJP+kqDYRnDmJmd6S7DFQxQDLiZijSzEXK5H9Gm3Kko2IWnzZdxNWK9iyFFCi6Dnksyh+w+43weGNwNFZS6mFTptAGsMqUUjrKgUTZIMByYraa/TEzrG5O6xdyevFWGjYUXzQ9JDPAOmxJBeWIO8f6BP22EfIfDJ8//3f/4dpWqWk5a8j8RnFNF750a6i4lZYlukfk4sG4HrCAROBVamiPLKCupYYJ08B0UKRQH+FQkoZKPDlSWBrVjPYn1AewhI5P5WwB8/5/DQMJ64Iem7y5+5vCbgLxVsSEo42UASdMp7pfgWBHCpEKhYr5IfZiHp+V8P7XYZQW0VnmO+pTYoMxtkpT18u4U7hb6QUvZFmSAhb0qszyU7RaCDxOFD+umwnzbloIUihDxoFGQkLTjngl5pwrqnFdfUPEQOWNlYYqnQ1h456JlB3xmB2nxOB2JLGr4kE2gFgmrk9fTvl5G51AyFr6jMxbREyzISwLIMIJApHCXMnPpUG9Ouc7HdMtu5aQXajbAJ4y1ip2Upnnf1c1dH70mhLNJbYxaRy7a/zBN5YbUoqhkREg+hnNBOofeOIZckSAfYoTCestEpZqXUyvVusqcxj7lLYu6tkzc82bxf0bwIT9m6qqpYx7SZHOVB3FVYNVKxPT5OYkoAIiR7ZavlSmVZAl2HbD/E1yrhRFfEZqlBDIrEd+hqsShJKX88mVaPH/x4xQIEI2aquqwGbfvs689qKicLGmEnzhHUKReoBcstqgNr6Std2JJYJGKOogyrUyxiIaw4FdmomUvaOgmj6IHDDszeKOlPmFhj/fr0O0/79ywqGJqrwFOaQD+qqJ2x2DkQBvJreVSDNueOWvuo5LMkzoy1LEUNZezCSuah2zUHsSrBFFIsy+JqgZpLOSn00wItZSSD2pyUPSH9Cie30F2HC1M+XzTZcoo81SM8EVY7L79zTQAaSLlitIJQJouG3w3bY5g/WdUbg8BzOQUWBfhd/rS9iKVNMRPzwbe2043Hgm59HQo1ziesf0LVwrTmBhlAViVTIYcrGjspVEUMR26/cU1R3Iq2DnmlJsP9URXbsf1lldgDAXO9HjZX4jvCtcOGkjrdc/rDAgRxFafqm3e/Ocs8L0pYLABP2InLgE1U3EzMbwT/DS/d4Ct+W/cP3R26Em8Z5cWi2Uch1Vk21vuHMilFBx4quafce0rpgoaMAyysZBtZYM5wf9bJKgvaLpNcMDf0++fORbGoatfn7a/eXupdWUPLzb9c+popnENhGr41L7Xbdftl22vElFWGi9zVqTHr36d/zdw75f5TOowSvuWmmTI53/zszQoBFgJn6M5DvZaLQIxFmou7IOSlYGHyJSRCFlVzDsREjmmyKOVNg9PrSx+85NO3BCFXgzZ1lgUm8DBPn/fzdXwMGnwLRa4N2onF4fOvP3e/ffy3VX+LtVkUJXy+lzx5Sc3f7xp7lxdAVgCgbGy67Wc9fJabd/Z52+vVTEHIdxJz3fBuFEz89OtPk3TvP77uxxU3VZk5kntt2LZU4THa8Jdd/1JTjRSEgbCNQIjfYveK8c2EhSRjnxeLE1YhTr7w9Wh+EtiDWdu57MSk02JlCdlQ6a/vFv/OHdrn0CriQuYIypbcX06sWHdCYkOL+l4qJMfieYqCp7kX6wdFN3xeUcyJpVgXgfVIf1OX68jhR5qWHrn/8+8/7xpFvXMQCxPlCFI07ikwNvN1na/wmtiBTvYMzQwrLpvF51nc3fbqbcl7U7RVAu2FvK2eg593pR/8mJ8LoZyMufmmBzq9MkI12Z0v3bki9DRZlwhBi02Tv/Gz5e5gMMVEXC+BGm4hIuMveeKS0p8fNWGUGTwpgYuS0VDvoubUKnVRNLVwLO4iVgdHNmINSmyHVNllNmqusxQRwR2v3VFKwLOhiP9eoJkcyeaJAUtMUUxP0izcZPAMqi4vMMcCno03nCPMD/6m09zrKR/fSKE4sTZp8jCvSN9+qA/wFRKulye+HKW55/6DnhzkrRcCrJVX7XhV5WchALzhxRuSFYKBbO7WaZcU6rc/f9tv4jq2R9ee0fE5FptsqOBi2WiEXp0NRQ5A+nk5NXfqmYc6ZZl0U13PqlG22BB7r7y3u3b0tXV9VviPcmDJe5RESc814+UyrrGYYXPjPXa4fofKnMD9zh5TWhGZ8lyUc9xz35fgVd8214kh1WS10NBkXZr4x4rStirwMgmpfSDR2LL4c8EChtWSQFEsG2WFQ1GqsQSO1nvK1ZPVOmUhfAjyTaWvcQ1ZS5a5nE0oFBgiVEGjmRbbLLNNqch4MbuKK0V869o8GgOWmNLjZ8ynjRfbOPneR6x5hE/dLIrQF24YhNhS8y6VHFsdv8J3LBVlCaxibcDtad0LfzxuhF7z9KrpNxkH4UXhBJ6aX1oRAcwpSWcWyKm06L3Y3KmREzvtYvnSMoNMrpT1AYtkaAqXrBfQjNo4oSJHnSqZr0XZd7utMLWsQRnXgaS9i4USttoymS857jLmzrTGuouu6/qvNdWFQZtRMIWp1pJbErifugbEaAOWySDC03OCFHSU8bJ7i7Qxxqd15qZndhglfKdWRoqqyYqwsUqu8zMWArRMPSH4vQQsSQBTzoYkqZAEDCKUrBoGOYCivQiWRSeG3VfcvSa9UCZrjKkWGmtOsLxPbLHwWSsoMdZXkBCJNapecDqm7HYqfThW50KCSvnOuGoGymaB9yPuBqUCumZ53wfefiD53oOeGuRPTZLpZEGPXUwQIegt868uH5+D2Jjzewr34b6yYoJwx3Gih6Y6hkbcRY+MfyQrxiNsP38rE/haZA1IcVSUsUBltwfLTCLOJAzYXmuRWn4jq190yrIV33LuI+fWEPwRtAl7aT34+ruvfQDvtMY//vmPKoZS3oX5L4oDbr6QF4gYK3EFct2MMxRziegA9kUjaeEgJav0Qa1IprG+ib/iQBVLQlizR16g+LRAp3bTcAoscgHwd0y5sVOkv0eXLjWUybkKiL6OLACsMGc+eKarF29+2s4B0gwwuc/f6nz/FdanSDHVcjLEBI5vNNYPXCPBdGG6ofUZfL31bv77rbKfPwGjiACEZ/c5u9e4iXjfI9c6slKzwYojmZYuFWIbtCm2DPgMBFMxbhjSZXXqsPUM5rS4ZqwYqV5z9ypcL2dtepZPwbSKgXu3xvAjXP87+nsFgPEP46n494NvPWjeG796I7wokFGFVUwlxiN0k+gYDjh4GJdmjvtF/7jIm9rDuA4rBddvMl2q56EPQFyrf7YbN3XNqRud6g9AvDubfZjyzbNgGw0VKJQqLEaA2JzYnNHxdwClpd4Cf7H3YG3TzqK4Czbbp97NL/cRi6WYd7Z5q+rfCMpUWQ5dImtGMsYIDIbQLjbvZfyELJPDiwWsVhKrJWSEYbyjZTGdXujSZkmN7xlySxCXxbfffuu2Hry1u+/j++ouw122ZLlG2aBFXWwO5H52sR8s5t7+rL3cu4YIPSmadvcbd9dMTuH+CMGmkCrYddpGp3kBEStXDchQwOQeBu8h2LSrZqultorGXvgl1aVL5T3IIJKKlLqf+DcEaJAmpUqDi8///Unv+2Jl0yOWox6ekhhCP72UGwcS/wFiMQlWzANgbIbuMrThIm2N3C/qqzc2a8sqhrIXjnusIrCUm0fAh3OYdvzf1v/nbnj8BvfgJ7bilIPK+gvawIam1wR1e1IkiI2C1Gmpsh2rCl0PqtbmlHdcct4lC+Ul77z5kpsXxluFzwKptlvF4coGfUo/hetHWJVTyQq4v0hbDyuPC/5p3FfcU/wtFu/C+EGnkKsExfqMn4f0HeIDsjti/+7Uysi4D8e5pS5ZqnAArZMKAl5M2o0Em00PyGk1fAeCSDkhisUDn3q4mGSRjft4XIW8h808hxaaye3LWD93jVmhF1eO9GFoeaEtWENw+XBiCDcE2n/9rtf70zJtk5OX3I/4grCyqm5XasxzNreOUkZSQYH0KT7fk0eeXCVgdClx2RRArGqpxHVgvdKCkyDOejPDLODGQxlp9H4I66//87W76LGLoplCxNTErE56LoaIHTaG7jTU7XXzXg21O9UG5j9Whw0W28D/nCoN0QgoMvePg9tTXhs5WIWQbCdLlsQOKLKmxYISylWt3JQBnzuyz5FuiXmX8ERjdb/TlLUTI2Uk5inM/AsPX8g4kXX6gLDolHEnqNQiI4zJCJRsMjfr3YPC+6bWwrTev1sxIxl1WEK/J/7BsBx16P/WXBz8jUlTlniqGaAd+666bw1REhsawllTkmMyDvsD4e6rpU4h7+l5Uc8Kc2oRuBfVgB864CG34wI7RsnErGq8aPqkM2PWZwPcuffONWOAWwvBRttQPDS/wvjPxie5GFKgb3IXNi6QnIC/FFVzzhwkqFmq68ZqjNCnu6+we829raBs3BIxWmrGHAVQ6pqwgYz5YIzv62ylSfmxPftt0GZ+ZtPB8tYoyGTBchBTRFJZVEUU7zEekGaf4XQbsIzQ11I2ACtkDnQdoFxQF0mQE0SZuyau2/U6U5ZYcXaaMFGoFIBF0lZPv0uGXSOKiA7+j1nzUoqIzjhC1knGlMSgHTel2jfB27F3sIAiUm+mm6XgdFRdGtCKGTH8ZqJ9i4BHcOPq0KdvDe1zxqwrNNRAn/ihW2+WmTvH9MZGwAJn4lucCiH3SBFNt6DMSZbJTbDU3DPNXeVj/eirj/xJTE4FOo0UhMFwBPRiZsUNI32rTwOaTCuXP6JR0FfEIRQJOa5jc8/pW8t6oC0+nl7aGHMUBsZwxGsjsoKyJf2cWJpfjPhFjdWJjDD6GWW1rPlXTsB6HYQlE4SpkrXz3ITnqjhxyiKnT8miGvL0kKhlJJbOyNrRG6Ckb2KRy7FoyTWWpSC8DtkBoVoYPJyTLi8p0bjXymzYA0YOqEp53nKJLd1db9ikaTngPReea2HXdeau5t95R0+VEMbZtTm/dmVNixXiwf0fdOtftb66bNoZ8ulDiA6hVOAgVJbjJQWp/QWsYN/z/3G+Z1Que38qms83+3x1uXqt6zsytbdTKyNMjiN6HuGG/HNIlTk6lvMf8y/LvSx+BknXA0JzPq02Sqv9IGXC09wjfG7PFfd0175QPo8/5T447t7jahaB5l0IuV1ixGlsWGQL0acoMlbAnOanmNbA2pRT64S/y4mwLNEcvB+Ak5PUqQkhmV0gR5BogROSbolQk/occv9cyGatScYsrh3eQ05gBGFOS+gsqtA1laJ4NzN3pmyaG/5pwyxFhDlCX6DcFR1EYu4L5stPlv+J+9vLfzOtP79Y9xc+FqqeEzJWM4KbH3jzgbo2Qw1r7oRgnsbKUehDhBwuLtrqIje9AAcPyjnz9Vdtv2rqvXFV4ypiLqSIEsuCiuZlkVJcOjK1t1MrI2DL+bd0x+5wrHvr87eqYhZiKY5hcbOwGJIOjgyVFxH89TKfxnDYGof57BVpP22SU0eOgBLzY5ksIN5NmDDhFZHA0LKn6JCISE6CsQUjJGSxwl+5z+ZaXCf10JvzzsRU0A7GPue5pDIT9Dzuk3FJRtYQkJNR3K+IG0IrFzsssIMbNnFY9Npw8xXLXhhnUzauRngMtCICYhY3+oR5Oi2VR2JFUERYEwRPisVGWzBjwje2aVoK72ZLbFajdElKKO4unpdCkQsCXokYiJVh/aUsm4z7LsvvYt5n++uKqchjYO6ftMFJbtWFVi2cO3qeWnF41uFiwhcTstvSCMmacPAASeNu5rwMD33T4lDaJePwUPReHZna26ljRgRWzAKwcrFZIKT6CvGVLoYk8RQxYhsR/KlibWXBAhyw0YBK++slq0qZkENA0y7xBATy/mar3/hn61oLZNPUC1+wbg07olufqLGg6DgSitzlgsrLh/c5vKZYVZHPnVMo74xpNIdESkAwKEGJZRQRAIFdkSKCeZ6NU+bZ9gtsb9fuiZSyB4wfqdg5AlJidsI6PSHXgi6+ZnEonDDiBB9AHZufOfEPqWv4G5ukXhNS5JJ2StVtYjKsehyxGAprPO5/837vv4+5xJpRUTUG7ecP1wSxRqxHMpf2/aFdk6leUHaC9T5w84HuiX89Ec3OkrYIzT1zNYzDswjSmK85BRKldhDr8ortr6iLWE04duqpX1SG74X9AJThOgoZaGOw5mUYR1R0wOjI1N6WMqKgBSgCbI8b9zCvI7AMxYOMEosMrSggCEEYI7gpgzCY1rLksAlycrECCOvFFktuEVXghNXykDUOqVvh4r1QsKwqn1K3hM1FqtqiIKAcDdh4QPZ7bdxrY99fWoHii2qxqXZjyh713qjSLJnC4tlM8K479d7JxwmI8vnHUX90z37+rCl0UPIoDR9WcRYUEXvxN7gxtEKj55ogVIj52dpUaA8ndSugUZ7HmEB4F0NKuPI3qR+l24llkliJ8CAR0mOLJTNn0+C+3DNmDSgbHMozcxX61JpAaZaqvwSs10s4ZmH+rvNXLLFWBWmfsbfHsEqRQSDzAgsnSjR/QxE455FzTCvULjfu4jadd9PKGOjEAGGrRgkUWcS8LFrDFsL5KcRmRfIEGSXyI0f2yH5AO1GesJbqoqozBEkPmoyPd/352j9P3j/kTeLgKPFZKfCcfj37dZiLxnX21F54RoYPH+769u3rrh59dUVo1eMrjyGWKtVoGp34ifV9Y9wf1vuE/BxlzJti+i6C5kvgGaQYr73Y2l5wStqoBYSAFKeDxlp8yTpIL8zxlz4O69rAUTL3rHNX0YNXggojMUC63c0EgitmGVljoTXc0+893fAzUoGS4TxAuCF0BWwqbMo5nBExLhKKeYUptKlaRJJGHIv1YbNio9nnpn3qqklStpaJnnsS+0UmUawOTgohl0TuvNKxX0Upm34TWbOf588INyL6PBwLrr/ix1e4nw77aVK++QyoLtVVrEOwAUuMRUyW6fpe4bvQxit3uNIddOtByXdk7v1u69+5heZaqOJKCakAQpRZw6l01pRMxXrC+pF58vS7T7vjRhxX+lma2iB8N6EpYKwIA+A5Vl+n6uXkHJou/tHFrud7Pf1eOPPMM7tmosUzUkIZWWWDVdzSly7dNB+eTAyL2EbQCD/JBVtd4FZbaLWq/PQyzH/WouIElcMdAlKBvBoST/Pdd9+5Sa9OcvvtuF9lolM99/KnL3e3vnqrKeR0ZUu9WGOLUXL4rT6lvSeuf6L76j9fud8+9tsapYyTVBjnIELgJzf+xDULMSWXExAZTY2mHhY925obevMtoyCXVWAZAyxqFpFVSmBqQq6YotRsYkHmA6nl+nBSZN62+kI2a2tepfhVNNlgbFMVEj8KS4Z1eIpAOneqOCD3vnXPW5NswFwDJwgbJEjJsmYR5uXKHQGWqiK3aEpGx+S0JkBjfHSMIHKGVPPY2Or1FsM/VQJEGINoHQIYiz/s8IdCpS4F7t1v0X7uon0v6jBlpC47+qWXXuoWX3xxN9tss7m1117bPfHEE9FrL7/8crfhhhu6eeed139tscUWyeunNz745gOfNtrMYCImB/5UFiAnAgs5NTFiZj82LZ2fTixCvfU6JMiOdo4/eryvFpxTsAkBqQvHaRcX0IW59hm2j3cdCLBeEDRnKSK6Fgyfx3TOwpSTghVjIKmosQJl/A4BQaCf5VaDxwShosGz4DFpJiyLBVYmUithB20Wf4RVQ4QoeQtYnXSxrjL1V8oWHLxn7D3m2KXWnriVrGKVuVaiMpD5oGO/hME3jC3av8f+nvzskr6XmO9F+m8IcWPiOk21gfUsbkQpm6DB8zdefOPSigjtmm2m2ZJjx/OxYqUUEYBywRo9+s6jk8G3kqXVaJycljukQA9+cnA03ge5kROfhbUyJqPlMHXI6oeYsVGWW5x6PFQujq0j6PFTuFK5OMMaWLpGVMi/giICF1O94N6Dxw82+3J6obRl5C9/+Yvbb7/93JAhQ7wi8tvf/tbdcMMN7pVXXnELLrhgzfV77723W3/99d16663nlZdzzz3X3Xzzze7FF190iyyySIdaRi578jJ3+PDDoyZtyRhpJtVzCDn147rQpuoyrqJmRH5zWkJIatNgETumfq6mqt9m6W3c8NeH1wjB1/u/7j749wdRNsmUiyFMAW42hBtDaoWA6cGsK24IELqYdl1+V18rR8y3Zz10lhv81ODk/Twl/oI7u5sm3lTFlRNjjQzbYFnYrLkoQYdlA3I5FVKXRVLpLbeb5RoqO8eL7l0PUNQloNiTts29rnvs08e8Ymaxg6bWfo4VqsgNgnumaD6E0Ou0HjZTfY9ciGvCn/ILMgnpsxUXWNGNfn909vO1JQmUtaJZ42Stg9A1HhsX1tPLE182XXuWtaystfy+/e/ztPIhN0/MQmdlLpEJOPSFoTXXjth7hNti6S3cf4WbBgWkT58+7pJL2rkBJk+e7Hr27Ol+9rOfuRNPtAunaWCyx0LC51FqOkoZSQ28pKuScSFpgAQfpkybKWj6eP38nFoh0xN6UXLqqMdPnsJvNv+N++zbzzyhkAWyYUJyrOkJrUCSlTAt64FoIQ1kLmABoLosZGqh64gTYQ4tuN5wtF87JqBD0zFWLVGMtRsvrCGUU2dEQ8zbVA7VfnHLFVFGGZdxCzcpNg8KIqbik9ZeeG33+DuPN2UTjiltVjxCzsYjG5dVM0YK5TVCFsd4UIRt1IRR3mXaTLoBy1XNe9w25jZ3xB1HNL2QnS5b8cLEF6IyJrZhh+UprBo9vBPBqjphwBpD1hObfXgP5ulbR1XvA2UV1Bm7zOiO6HNEdNxDxUMTEIaEnJb7iQPjEvMv4b73ysg333zjunbt6m688Ua34447Vn6///77u08++cQNG2ZzG2h8/vnn3oKCNWW77ewgyK+//tp/6ZdB4fnggw+apoyQirfV0K1qfr/b8ru5v435W2VTGrzNYHfgqgf6iZdTxyaGY9Y+xvXv098LYQIVT7nvlMozjlrrKHfh47W03M3Odc8BE3LgZgPdSSPjZuTOgJz6NLsst4u75dVbzI2Oz/9tt795C9Hlz9qU52dvdrabb7b5XL87+tXMtxj2uGkPd9OYm7LfA2H02pGveQFIps1hww8z23rNjtd4twJukX2H7Vsj0LgHGPvxWJ/+J0K7KNaKz+r+ib0j9+Le946715336HnZGyP3h6WT2Il9btnHjBfaadmd3E2v3DTd15LglPVPcSsssIJbd9Fq9mbGg405pii90f+NSj+HsqcRy0azuDmKQBvP3vRsf7DjXWWeT6u25iiLDx/wsKdsCIkYxSpAlh2ur71vsVNoccthsRTAiXTifdWHcFkvf3npLxU5z+8GbjLQrd5j9arg1DBYdemC9bRhzw3dQ+MfMv/GXB+46UA34L4BlUPDoG0GReXJBY9dUKljRd+STXPeHudNk5iRbt26NVcZeeedd7xr5dFHH3Xrrtse1QyOP/5498ADD7jHHy8+YRxxxBHurrvu8m4a3DYWfvnLX7pf/aqWAW/o0KFeGWoGXv3yVXf8a8UFiTyl+gqXuW6zdHPnjjvX/ePT9qJSZZE66cUWkfipZQE2opzo03KsHbn32bP7nm7ohFoT3/8aqKdz68RbK2Z466R07jLnupe/fNn98Z0/1nz+F71+4S54K85qaf1dz7cYLht/mRv+YbUbLIUzljrD9Zi1hxvz5Rj/dfsHt2d/Vt9j5blWrsRZvfv1u/6exALha7b66MieR7pes/VyJ7x2QtY7ct9DXooHYYsL6m/v/61KgEJcOPrz0e7Usae67zvWmGsNt8YP1nBrzb2Wf3/emTE5/61qK5x3Paxwub/m+/huubLIEwQuc07NHCgL1sqCsyxoyuxcMB+ZK7F5RgzQnDPN6S4df2myHb3n6F2Z/3y3xmb9udd3j376aOUZ6829nt87RAZvMu8m7v6P76/8fETPI3zbRnw4orKeyoL279R9p6r1GZMjPEe/p25DszFp0iS31157FSoj05WB9ZxzznHXX3+9u//++6OKCDjppJPcMcccU2MZ2WqrrZpmGen6Zlfn2g97VaihrXaT3cc9PnbL91zePf5cnjm3Hj6EXXvv6m4cc2PN7w9e7WB35bNX+nbIxA3jNHJON1w3dMeh/ntM6y8CzyEwd8slt3TXXVJbCMtCo9YdMTui5e+10l7umtHXlL6H5WPmxDb2k7HuimeviLJFXrj7hY7/OLG//MHL7v/d9f+qruFzn3b/1B289MHuT3+aWoxOPr/aaqu5trfsd4/9nXHstVovf0KzwAnzzufuzH53njNTr5ncISPLZ1rpcd9sw81cn4X7VJ1wxcrx+g6v+z7CvK4tfqusvIpbYp4lXNtree+ItbLtpbgiQmo4p2yxooiFBqzy2Sru9EtP73BXZxGe/vxp/3XZvy5zv+/7e39qJa7FvVV9HWM1br5xbrNVN3OruNp3K1NZOqZIN7IuRRbtvNzOFeugdU+vpC7WpWYOlMFG82zkDt3mUDfTTDOVVmp0Gn/PpXu6rj26us3m28yd3f3sGovGNe9e4/s0Bvp8/qXmd4feNzW75axNznIzvFEbhP3Ip49U/YxiIqA99318X9XPQ/45xDOB9/1BX3fsZ8dW1pNYOYpw4nonul9v8uucLvHrZ6dLdqr6HW1ACfr5tj93i89XG3jdCNi/c1AqvBlTy4wzzugmTKim6OXnhRZaKPnZ888/3ysjd999t1tllVWS184666xe6dBfAPNRs76W7768Gd1tRUFj0tvgqg2SDIONwAv7JTczI/KvHNWuiAjCTRW/Mn54/ONFmRCffvOp22iJjepqM+Wxec6hfQ71PkXK0ucAv3bu88L2s5FCLy6kSSt3bz+Zx4IL/7jDH80+sFJ59151b9+3MUUEPzfvyRcBXd3n6m4+d+DDA32dEoJrdWbU0esc7ZbpFs9OOXj1g91MM85kVoTtvWBvc85O+GpCKVO3FP4SU2y9YP7xjr994rdVz+c7bgaCkj/690cVRUT+Rt2M1z953eyDUe+PKrUmacPJ95/s2/DmZ29W+ujhfz7s+4VxqpfVsqNAX9IPFz1+UXRu4Z4Z+dZIk+3WqhYewrOwbnle1dzcekk7e6QsmFMoIsQksEZJB7bm88ZLbNyQnHzwkwdd79/3doOeHlRXdlSFAPK+E71rHlcIc7Zste6TNjypZo6fcv8pNdkt9eC7tu98SRLmtMicEzc80cyksjKCzt7y7Oy9j/UTI0WUNjT7KwelZsgss8zi1lhjDXfvvfdOfYHJk/3P2m0T4rzzznNnnHGGu/POO92aa3Yc970GJyq02hCiRVu/D8EEbHQiiubua6S0TX029+QUmFocTJ4n3nnCU1wTbFm0UHkGEe1lhTZtpDw2zyHYEM366ueuzvosZEz4MeV5VgqzLCgi4rXAlYJrZHoQ2EkaaozYipRf0tusLBAN/h4r1iXlz1F8wgwITvgxcB/6oyKk3GQ/HvQX9UBCeBP8M5f7tOewDbq6Z4gyhdCovgqZWIrzoAi6/4TN1yqPwHta70I/xGr/cC8rjVDTmVsbCgUWJe2RL83yarFaCpNlmJbbrA05htg81+B9CIwvsppKPSwpwSDzky/GWGQGzyOeIVxD9Id8lgPFiHHFlZ1zU8sZf9YTFPsWwZqsYZT1GMie0Vhu/uVqrtHVi3PamOr72L2Kxuy1j2rXH+8Peyv9S0ZivZgxUi03pxBnSjZZQFbG3jNWbXl6oLS6ivsE7hDM0i+//LLr16+f+/LLL92BB7YHyZAhg5tFQCrvqaee6v7whz94bpL33nvPf33xxbSr1ZCLnnPb2QUMPrTXFsJaC3qhb7Z4XmaBrhnhS2lPEQz+e5urcJSQzVOkFV/w6AXZGxT3J10NwQY3Qi70ZoBgJAAsV5jxmYlfTqxYd/gcVpWQ5hhKZ4RrKHABGw3cD7FnDh09tEKDnWNtIaqcNlmnOCqYWspAUW0RKyWZ9tw85mavaGkKa/lbrLqnxdvCd6vNMRAIivLWqCk+h1ukHteI0GLLewovjYyjZwBNbAy6v2VeSh0cshn0PILHJaT8Z0MuQiPcGOdueW5N3aMQ3HuDxTYofIb0VViCgffVlW7pDyr7WhT98tmczc1CbB7JerLKI8jPtJOU/BhemvhS1c+vfPiKeR3zjwOadZCifX/Z9S/ZZR18/avVD62S56Sqx8AzqUkWUyKEPybX2i73lO+/j1SOTtVuEpAuTaZdDpClHB5i44kFNORcml4oHTOy++67u4kTJ7rTTjvNKxWrrrqqt3h0795uxn777bfdDDNM7bzBgwf7LJxdd50agQxOP/10H6j6fQU1M1JpUmGFX3Dfm1P9gClAmQ2dOkLYOk0eeceRFZ8kRDaQssVQJiBWrj/41oPdDsvu4OoBgvGjSR9lX89Cw7Sun//n5/9s9qNOdw7r7cTep+hd+btkdPAdy4OUapfNRvNxSFR72I5URdSi/oJ59PA1D/cbSlEpecaf8RnxxojKHND8KrrNKXjlr8nJI4wlZF3nPHxOheK/kSqpcOtsfvXmNe/CuJHiXUaR0hu2rqStqxkLv4O17mIspBTau/2V20uXaue0zOYv1ZCxED7w1gNV98dCidWA7ynq8tip2bKU6T7TVhWZx7K5lZnHKUWENRNTcOT5HKxSz8sdZ55HbRYOirKG9d+gitcbeqpfff9PobqXGk8xK2Iq1f/odY+ukhlYyiWVnPVBfJ23RBl5IpVndSlmX82tCJzisyKtmr0l1d+i2Os5M71QVwBr//79/ZcFglM13nyznUfh+whS7VJYvtvyvi6F5lYIuR8ETKDcRSWF82IbnD7ZQG5TBqLhQ5AVa89dY+9yG/XaqNR99f3n6zpf9rXEToSLWEy7QrQFQlplWVhFromiPufv1+1ynVtgjgW80NSmZK+stLWz5fJviMF0LRyh3BaiIy3cdGplalPmXUThEqFVtBkwPgKu00RoYj3j9PfQ2w9F+QYazZqywDsisKGkZh1wIrYsVvSnKNSxthGYrU/1Icq2WzbskKxKeFJQDoTTZ8zEMYX3ExbSrZbcyt39xt11tUUrQXxxev37a393s84wq1tq/qUqVOrMc4Q/cmHQk4Nq6ihJtVuUqLIKMnMVZYjyCtROCftc4oqsQnUxMN+hgpfNPzWnNftqI8HF+rAQrkX9NwFtggdHDj26HpaQK2o5EDvweW6cg9q5cSgGGM5LFCMtu3hXFPYtl9qyRt6ECC17H//74yrZo68pAp/BQmIpEWVLhWjFfnqi09emOfqao92g8fHAKOi6OU2kijKVrTUj9TaAn8gFrIS5ke9lWCdP3/h09+sHfl0qI0YWWr8+/UxSoNjJ0iLXuW7X67wwFmEWXqMJwRolhKO/qTUSW5BF/auVo1hRq+tGX+fjGXJqUTSjEB+Wtb+/+vekxchiwk2Bcdl22W3dba/elrxOj41FxoWJHJruUAklewYFP1V8LdU2XBoPvv1gshhbzrxs5O85YLwZdwsxpTtVBwWXj2xS4WeK5EeKj0TGqlJjJXIfzUZt1XJJbXaafbWeOc/7/3iBH7vjtj3OfT356xqrqVUwz+pj5gbWMnGL59TJCdd9bG5Zc2a3FXZzN750Y12ZP43gsDUOc0O2G1L5OdXuegoHfu9q0/wvgbzqsf3HVp3SNZjs2k8bA3/nxJgDNkYB2nDRRCEjpSgYTgIvOQHmCPqPvip2tUg8B3EUgHae9fBZvgAVFoMUuJZTAUKI9E9dAlyEgQQeWtYPhBaskMSncLJtJEsCIq+Uq6eo/+XkwslW18nRPnwpOa5jQ07e4GS32A8Wq6mfoWNjUJTqiUug0GBR4OOdrxenAOv2UoOD++aenKzYIX7GWmKZtHFTQKdeVhFhbhOYeu0u15p9tcNyO/jNJsc62ejfi0A/Spl3K+4nrGWCAiDzw1oHKAfamqHjY2QuodhbEJmROpnjjtbPqnmfLjP42JcwlovnUx/mrAfPSioiYtXBSoHFNmeucw1yh+fBCLrIbIv4WAaClWERPuXeU/x1sv6ArpEV9jHtkzpZ1L1665O3stpxxqZnVOrWpOaW9XusW/Vm/jQC1hfW3Xos9qHraXqj01tGqNpL2eS7xt3li7dZlhFOoTnIrXoqtMKx07QljFEIMLe+/uHrPr1MT7CQyrhZ1PKY29dYeA2Tgpx+SZkgQzbCG++60X264Kfu7EfPNuNwQh+whpja35/0vrvw0QtLV4vFTRMrA15mocbqDYXU/latIau2hSB0Da3RYw1vUm+GcEqZx6Xv2ZDILigzZziBXfZ0ubiOIpAVdd0L15kWMpnbZz5wpvv9M+0bnDVHGgnaLcPdUWQVsU7nKfp8aX9o1Yy5AHU9oZhFhSD1opIOYh2x3G3aclLW7C8yqyjuwaqbIhVxwaNvPeppFcJnbbvMtv5ApF1PuWUcQheIxGURy2ZVR0YZQyn5PpTs0OsCegCUjxCadr6oTo/FwaQp75uBlmWkBBiwJ/5pVxL+6tuvzOtRPHTV2tzIZ8DgExSXo4gA6pRUqn1udJKZAquDacNqwGQm1IP5u87v4xIssOHmpAizuM9+5GxPVjTwkYGmBQSfboozgf6iWiUnTgSVlZIXA+ZS3EHWZ3AjFVmcNKzTqa6yyXcUzPe/eL9GEQEISbEGCfh3mBEB2VHZDdVKvwxTz/U1EsGPL7ysIgKkYFyz4Jk6tzinhk9D5rb0s6WIANoSS/3OfT7Bho2ezbrP0d08nTNfUvJB2q/Hi+86dTcW0BqueeEh2X657QvlEc+N0QJIGrwG71akiEhWGun4RQGYuO2siriAMbcUEUDsDWvuuBHHVfUzcR0571x1zzbns/lQzMM1JBmIIJWe3GzMkEgzlnUxYKMB5jX0g8QlogwWIbxHzmemBaYrA+v3EdDi7nzpztnCWJ94BJL1Qs2Q8FS3+4q7m9UROTnnAI4EKVctp28d8GbFssjff/f47/xGExPgRROUALXFP188qiCxkWF1IMbgz6P/HL1XrDaLFqySeUD6nFWQUALxUMis4LU3Pn7Du5BCcHqygk85VRDPgmJXJrgrbE+46RQpmLIxrdJ9FV/UKydaPkdwUd33kiempmuLssFcoGiXWGu85YANt0t57pJpBU8Pv/1lfpysuR1u7jHUoxwxF7DyoFzd9UbjQviEESe4z77+LKp0s6HpgOSw/fB16Pn04sQXqxQkZA1xYZItJHFXMZkg1qJU37HmYiytovSI/Jk4aWJhzA1B60OeGpIMohfwflZcXlEWXQwS4F2m/AWWJ/qNfo4pZdeMuiaZnhxi66W2dve8cU9hjIxVfuTSvpe6MR+O8fI7xNFrH+2OWe+Yqeti9UNr5LvIVOnDFHQfyc8dlU3Tqd004z4cV1j8TgeblnGB6AqlVpBfziITF1Eq6C2ECA0Wd8r1EbbVp6CRTgqXxJTNQZ7xkxt+UhXhj4K04WIbFm4QOe+51VJbuTM3PdNHnoubIxZwFQsklUVjtROOCasabWiCJT7l1w/m0SmXMYNHP99gdkHZStHW3OX9EXz97+jfoQpJ0ZzOdX8Wze97xtmbQzMCB4sgLrEUX05OW8LNVeaw1XdhlgcEfLGsEYKLdeqxNtlrV0uqfalg2RSgGThlo1Oq3EGNjrkgdMFIJo3l5gYxl8Z+q+znrn4+j+hR9g1kf+xwpd16F/3joirqAUnjtyDjDSz5q9dSTh/muAG/l1V7/9eUkRGvjTAr91plvOtZIHxWUurCtLIiM6cuux3LNLFSuHKEhsbGi23sq0BaqazhPQFBmWTT5ChlVP89ZWR7sFkO9EIris6P8YHgOntk/CPecqOFWyyqvJGsnWmRPttMaIFSr3DPeUcJfu0+Z/dSCl1sHCyumaKxibWTMgFsdDJfsGYRxNgs5SuHa0XW81yzzOWDKJsNSx7E5AYcR1ZsXEqGhf1l9XUz1oI+PDQz9o0NmvRc4TXSmT1hdhDBsZaFNTdGLlx7qffQc/71j173qfI5B8hUbJM+hMQOIFJegWsJKg7TulvZNB0AJmZRzAALUXz8uTEhAoIm2QAwk5LLD10wp+lYephEkGv20VimifgEQ1+ujj3IwQNvP1D1mQsfm0ppbJnHz33kXJ9FkbMol5mvnQchF+KfxVLBiey0jU6ruUbePYzVkDFCATlqnaP8qUTH88SiynVOfRhrUzQ35H5F5QB+tPSPqu5bBit2q6bKzoXwmwjY3MvEx8SYLQnOrKlz0sV5U/EZD55R1zNkHDBL6zH9zSO/8WMIYvFJPI9Aa+YLLokQ0O4LGGMOB81SRHg2Cndq/E/f6PSp67m+rimEJQ9icgMZhlsqFx9M+qDmPt6Uv8ZUhly+o4w2qpTjvhImUVmPzQDtJ6NOMt8spmeJA9yx947+gBYqSVioc+VDyDMTy7IkHkhn5f31xb9mzc1UDR1xOcViiWC/rvCbTOENChWRGBvstEanjhmhwymbTMVEiSUAelFZhDS50KQ2lrYdYs+V96yZBBaxkcXIGKNoL+sO4FqCaw/vc3hUoIl2XWTdIeYkjNUARSmpEhtyyBqHuDMfOrPm3UP6aRkj8XPGeAZifnHuhyCS+h/i/snhRtCkagTPWamxpNhiURIipDIn0xc/eNHVA+oB6bnEv7F6FWUahLCYLSUGJTzJif+5HhcUn9OBtDr+RsaQFNYwK4pn9l6gt29fr3l6FRI41cuka2G/Hvu5Y9c51u3zw32iFpczHjrDl51gwyO+o4xLyMp0iFkLQ3kQe09I1eC/yAXKm5Xxohly+X7FM1dk9+vP1vqZe+6950zOGLhzxKIZW7PNgCgBsThAITTDjSLt0XE5MSZl+iDczKFbsCC/F8bgC/5xQVbbU5aRcC7oNlskheH8enD/B916vdrJ+KY3OrVlRHhGSD1FS+Z0BbOgJdBCRYQJgemOU9l2y2xX94lQT4rwdAOY1GEUN9TFNZprZL1eus2l/kRbxkJBHAQLVASatTmleEb0gvQsqke+5s5Y6gzP50IF0dy+QhkIg/di9NO61onFM4CydvKGJ5v9zoYqp3GeKa4NUjExa6faK/3BZyxLjgBllABSBMK0gOYL2b/H/n6TDIH7rcw8iJ2SUnVO6M96NvpD14jHH4mySUGwWGYJ89XaHIoyT6wspBxQsn2n7u1l2CXTzcq20JlXXBdmwpHunQvaiWVKt9fa/FIn8jL8F/pAoS0CZMpYfCi5Hn8CrS1FBCw050KlOTJyxo/3sJAKjqbODxbWsF/9fJoSJBti2B7DquJ3uP9fXvhLzXX0o8xb4UBpy3hXr5hPqdgcPj81F3gWiQZFB8FJ305yHYVObRnRg0XZZiBpoDW5/sbiIyAyDPqqF7H6E1aRKYLQeLZm9lxvMfvUtd1y7Rwp5N9f9Fh7oFQRJKIaK0GYuUIkP0Ji1plmrfkczx/Ud5B/ZngqX3mulX2AbBEPBH2P4DCj6dvaT0tyXTgmRK+PfGOkuUEm68EEFpZcK1i4WXOCwqQby5bgnviumx28qmsm9Zqrl3v+4amkehooWjnPzWUdbpaVYa+V9vJmcIszwUoBl/nIuiRzgxRSSb/MUabCbLN62r/5Epu7L1+cmvaaKganrTM8m0wqqvXCKOtTqx+z2xCuE2QOp2kOTVhiQGi10rAsRRZiFkN9oJD+ojCnJkpLtTeG1HWLzr1ohfbeml8hG+xBqx3krTRF78fct4J8U9lk2v2VWy+GuBIJIE3xsXiL6ujrstiy9XsgPyS70rPJKgWQf4t81IhZfixAK7DF0lu4jkCnt4x88M0H7v4376/EFlincSvXH6QUEVk0ucDawYQPy6rHFgtZIZrZkeuwOoTY+s9bV1VD5SSmq8jGThWyELV/lX5g8WBFGPjQQJMpFvdOyIhI/7765auu3x39zHeRNniege3aUzxjbJRSOZNU6hC0CbN4I+C96duchXvJNpfUCDiyjGLgnmxCIZeEDwpes180RTCMSdBzS9dMSjEFS0xREbgvKc+5rMPWCS2GmBWC1Pci15Uo6zIfCUwVjgxI+SyBL+MTMqEK6lVEeIel5l0qe1OTU7CumkqGBSZzNqQUx074XCxrut5NcowyvRvEf2hLEbxEKDzh3EYRmdbB2swDbaXU7M20MWSDRSnMPVyF418USyXFHCWOiUwbHZdnQQ40uGuLWJ/Luv3P2/K8qWRwRtwe9wzTgXPT4gUD7htg9tP0QKe2jPxx1B/d4S8d7tpeavNC+MT12yOLw9M4sRwgl6SMxTNsz2Fu0jeTvPb61qdvef6BVNQ91g6+wjTHGB+JxFbAaZCabLo8N5/BOuKF+ZQqstwf4qCiICxgVVjVoGjb0+887R7712OV7Bx5bgpcR5CkPuXh27aAED/27mOnqVDMvTekcGU3fNrvFdwpxeaE+yMWGX/Fj6/w/2asCSbEhy8m5xjPjAV80jnvJYRJuQFszNPR7482ORGAVEwW837sVJ1CaOFgAx/y9NT6G6nxqbcAYxGw8nV37ZXKi6xE9DsbK6dWfVLmOzKFw8HQnYd6zo1UNhLXo8DEUnlDIHdy8NPVfuozjkJuF12YD+bbMmsuJ2swBaHKhw7+shUuc71W6+V6L9geGwTke8winFv8zR8+I5/FchWuzZz34VkUWSy6NpbIYP2NOSKWcLG4WCBNGHJIec/cZIOOLpLXqS0jLDZO6mGQqXUaZ3ByTZ7yGcx1Ugth3tnm9elWTKaiE5D2MfOFJSIGqOHLkmbpyYbgsVgrLfN2rvB+9J9TJ3+uMKK/CADV6bkxPgS5b72oN0bAuk/oh77tlbRPVkD/wCjLKTemiAgbJX2CwGQeEcvDd37WdXGKrH1TGpwFrYTGLAoaCMaYIoIARfH1QrSLy1JE9Njwbyx5OruMtuQwraIYLD7P4magM/fADVXvHGGMj7jjCN/PsViU8HracfVzV5vzA4sesoJspNxTfsj+HKJIdmhgqZFYKc12q7OayhAnSlwDGTaNQLI9us3SzfOggPCdJQ5HrCdST6uItRYUkYI99FY75UE9qFdG7bL8Lj4eL1wHxEtJPaCUxUW7lhjHPW7co6EsvOmJTmsZyd1cxVSH6b4MQgGIQCX4DK21iOtAJhTuolQbwxo1OdCLMtYHZIcIt4qgmVkIqTaBGAV9M56DkvXNd9/UTVYWQlxkcMlYFqYYYRJjjMvG6k/qesCTQoAom04qc6jI2ieWgJxMDq2E6no5MVKylDDfdfldvfUNi0yuO0RiX0jDjMVDxIIaNeGWvIeVKqnXVqqmCifKVJwR93n363erfifxIFYtJ9pRxLmTyxjKsyUrIjY2KfkWPkPPKRDONziSSmFKbBe8KkXxHEW4fNTl7pse37gJoyZU3LxSx4filMBin51v9vkqVYiFjdiaS0mXC59NyDypYv7N5G8qxGU5vDMp3GgcwoTyIIdQLmRfLbs/HLXWUR1iFenUykju5npEnyPMoMuQbVAEvTUZtTVC/L24V2Jpo3pzTrWxHu0bGvSitGEr8lxOfvVQp6dgRYCn4i4s8p7YfcUVggVCCI94DqeLRiH+2ZyNlvGGLj/sZ8zAVv//Z/J/KimzlgIRM6Va1j6tuHCCTKVZE5yMYOckrF2SYjKfa9a5KvTjKWFOhtnMM86cJK2iTALKgmYSldiXsDCbfr+JX0401wT+dEk5lrUTC2qNrS3W7sJzLez/3XXmrmYb9H16zFqdaQFQIBsB/UFWVo85e7iPv/rYnXzfydHr9NigBOl+i8k32k3Qb5jinToAFW3KIbgeegAC2ZuRmvund//krnlvKiupuLeQv+K60Km6FTDFeXSX+vYA5gPKxtkPnW3KGdqBWx+5KJQAucRlZfuljf8KspX0YQILktWG7ZfZ3tf1icnN/n36u45Cp3XTMGB7r7R34XXEQViDSowDlREJpBp/9Hgf8MW/iRWxEKZ06sBQHVCqy24j7MNCZxbKBMqSsSAkYRbRF+RsViBtJe+/S7G9X7e3sG0qQ0bw/ITabJAwYBDyHsv1tfnim/vNkLHh5ITpOQzuFD9zo8g98VNskWymsAAc7QpJiVAIwsJ5FqwU4SKCPD3nqMYajiUn4KtGXWW6QRBeWAo0wVws9ZtKzyn3Idecv9X5VWneui2We6gqBbKt3SKgzfLMA+26ivHu7LLCLtEUX8m64jnXPBevQ+KzxrZpj2kK3WEp908uiBvBcoflMweMDRugLsBorW1cXlie+izcxxw35tSYiWPMtYH7IPx9ag31G97PDRg5oMqFop9luVJS9ysK4hdoV4blnguh12Uor8RNROA+geSxdqEMktElsqaIHM0HrRs0A/VA+jIky7TWJrjttdv8e1l9DSVAR1lFOjUdfCN0wym63BjtNuyrVvR7SOGO8uFNjCroTp/wQ61bTNtXPntlMjUy9Q7aJC+wzL85lOIsDAJ+9Ql1zPtj3J9H/tld8+41dZVDl/aE763bb9WcSQX5+X5XZlwEDn388sSXm+bCCS1oQrf/kxV/UlWLB1cG12CRQqHIoW2nz+hfTZ2eKh0A9LWN1P7QfU8/htTa8LOk7k36M1VSrbYyDqF7yCrfLgXF5us6X5W1BtCmg2+bagEMoec2bjAyH0JyvdTJlWfDvHryyJMrrhUpoxAbv+lV/yYca6BJ/GJK4goLrODnfpm6M/QD/DCpCs5So0WsBtpCac2dj776qCZRINV3ulxHUQqrljOh3JXxQ6kIZWyKZCwmL3XtLE2eyL2OWfcYL2tSbsAQYR+k5r9A968Fbc0/a9OzXO+Pe7u+ffu6mWee2TUTrdo0BWikVof4K63aKCklRxQLuAI4QVG1dc+b9iyc+EXCH2EdK/CUMkPKhlZUO0HeDaFdlIJpKQLffvutGz58uFtg1QXchn/aMPpuZcdF2p+qOaPHxRqrMCOFzcny+YfIEVA5ygkQ3z9zo9fcvXw8UREXi67GqgXhZU9e5k+lKFnaymYx0jZS+0PqLoUbXkwp0qBdQ3cZagrjUOimrpW5HRZQjBVaDNugFR8LnIbvGmtX8rXcsTKGFnfEmj3WdM++92wWz08jgDWUuAOrX5pV68Vagyffe7LJs0IMDuUZYrDWoD4c+eJxC+3jJnad6IaPHR5VRorGPaxpFVPacw8DRc8IgVzhvWRsytTy6WKsCV1QL1VokndNFevzpJ3Lbee6z97dy+iOVEY6rZsmZsYqguSHH3DLAWZtlFRUPRMHrZ/PsOFhcrb8s7mmdjHLYZKOwZsoVz8sGl2eS/oDnvjXE1n9EzOJYh4OWSpZVHrxWuNimTol6ruo5gyI1bGxMlJyfP6S6RKa+XOgGUp1tpHMjRwmxk16bVK1iWoz9IGrHuhTIUfsPcLPD2IJLJN1qt5LCMs8j8Kk+SBkLIRpNFaPA0jMirX+rPiY2LXW++emMFusyiG2WHILTwBXM/ciQYoS7LnDcjuYZFK4FpvhHkyBjCXdL4w9/fK7x37XdEVEZAjjDcW7BQKxU7DWIC43cYFT0fvqd682FREhSAQxt5y0U8elpdyZsfpjOeNm1QgCyBvkvR4baWvO+msL3os4Rl3ZV+a/lWHFOxObFmv/kXcc6dfv9wGdVhlhkDShThkwOWDZ1JMBszD+dl3jBNdMWdCeorS0mgVcIHuJaA+JtmRxFvm4Nc9JjzlqA/ZyFiWLY/Tno92T7zxZc3qitHdI3ha2lRNsCDHoxUiL6EcUC8t/jHuG4MmyJEjck5OYKIF80bbpYYLXGPlmLcus7nNJhUTIkHWRujYV+c/7YmbXFOayXnR/EigaKnuxehwxmvEy11prtvJOmXu9D34u2JxRLCCAC9+flNXYQYb+vHnMzebfyHRq1jzJVWp4R4JJc+ueFEHHtgkbM+tI2Ic1+DkWjFwEoR6IZQxqgkSPtoxChVMQi3VC1qWCT3WcEoGeuenDMU4Q3mvARgNcWVxsxDEy/3VZCzlwCclebN6l4mmmNzptNg3gFPnpa5+6E187saF0rMr9hh3ov4vZDPPhL0b8IvtEos3qoSsmFVhURPzD7zH/6yJwuqBckUAmS4Hrv/g2L1NAL0rtmz1t7GnmyZdUZ6wuQostKXMUlotZP6SWD0oZm0WY5cN4xlxKEoxpmTd5T5Qhi+DuyLWOdOM/G+8W/3xxfx0nkRS9PfeHKTbFmZJC2VRqhOn6i7SfRItS+4gP6H9HPHJeB9nylSoQpiP9RdmjOnUsm0PTjGO5YZMe/NRg8/1DSvJYxoLMOanEXQ/hVIqFWNPHw7kxrS0cRSij1MD90wwlSJcd0GR9so6u2vEqd2SfI90j4x/xFpFcRSTmQo1Vsd1h2R3cwWsc7EsIFBG8zTlr+2HLZ9B1aS/3IdbrsMxFylJWNcfdZDfoqUHeysthSpcmCJGy1PEZ+qhZlAmTA0tJaBWNgfZTh2feb+Z1HYlOGzMisQzn/uVcd+rYU12zIf7DnMqvTEoK9GleBcuXmoIOyCwK9JL75/qQxa+Yc72OSWAhhjExIVIbB7wsmGxTPl7xAcMQWYaYybqPACFYFFxWFPAHyJKCrroeHzRzgg2d/iGgNmcz4V0oSkhtmq4rdHVbDd2q9HMZa6rghvNONgwsaTmpi2F8jATuESQoY4brgBO79W5c/9jB7XU4wjZIjRArdko4X4oYj3NQFGfw3wzG5tY9b/UlLYQjIwXp41j8CeNFVeVYMGUMFkMuyNlEsbygAKXGJozN0DFtWsbWEysia5TsP6zPVvzG4CcHJwPiaQ/uuz9PUWqaaWXFMm/FisSewe+H9B3iDu2TPqBOq/27U1tGAFwB08LMLid+qfzKZB/3yTh36ZOX1myqLPKQZMzMm0+cJOT0xjPZSMP34eSgP1eGDpuAyOteuC55/ekbn+5WXGBFz3rJZp4SJvokkOp3TipilQlPMnJiThWjykHI2ZGiWo7R7MdwzsPn+PiBsicfmY8IMT5LWmWOdYV3gYq/q+vqBWzZ5yJcic4PFZFww1hnkXX8absIcpo8aNWD/L9ZC3K/1Jhpq4zVBgki15a+61+4vrIh+dIOG7SXdqhXedBuCFAvffz0cOExblsuuaW7Z9w92QGytEmKumHtKAra1kSIsbpRMWtjDLEK29K+IuAqxxJjVY/W7xn+rLl39Dwvu15451DRCHlf5p+9umSE1T6YeR8/+HFvcWpWNl+Kx8jXGLvnxJq5IszCfZfr2yEpvp3eMnL0NUe7S8df6qYFUoIInyOcB7ETaGiytKpGxhZ+SFpVc0pNRP3/sPsP3XMTniv1PtoKVKQYaJZNS2lKpbByKpfUQJBjeQlP/QRspSwsVkR+IxsK7R/70dhC61gKtBGl7NrR1xZe6y0pPY9wF+17kbt69NXZilqY2TOtszBiwMePCZ4US5h4IcAjNdRqg1jOrPleyZYpaSERK6WvJ6XcEKyXoorTFmhfjuWhEcj81KnjsPvGMiisTStV9NPKTEvNCfqLAFSLlK/e9PJVFlzFPf/+81HG3LJzVKf5WgqyuIqJGUqxZedYiHOyu/6ayAriXsP2GJZV70bPOwgCwwrivihnn35edsZqIYV90yha2TQZYOAHjbcLssXAJIXqOqfKZmriXPLkJd7vGp5Aw0BA/Tsmqa4aGQs+soIHdRaH1EZhsYV44f0XPGV97vuE6aM5dOOcGEgLzUm/1FUzcQ+wsaP0CAFWrpBg3HA1hSRjOh4nFpF/+OqHZ93fygIivgGBRCE0BA4bqM7AyY3SX6DrAlnX0v7B4wf7YGEsEZjiiz4Hx4AvRx6wesrmMT1dEysuuKIny+KkTkFEvh9060FmG1AOJG7H6jPipEJivLDiMaZ+PR/IksJdGmYr1aOIcD/WkmS/6bFnbpCG2wxIu6QQJsobLL45oJ+KFJEwZo31l5oT/A0LrYYl23IzGhkzSxEBFI+MZTDGkhPCQFMrvkrYVWHKFtdRGeisNdxCRfhw0of+uzAl63kCMRtKEYpmDvgMAeyhIgKov8Y+IrWQLEK2Vm2aDoCnPy4hYBg4zGlspuJvZLO5Z+w9ddWJQcAxaTAzcuq3sj40l0UqhTVMjy0Cn7NMiPy+e9ep1UiLJr1ndFykT5R+OLy3IFaNWE55VlCZ1Se5kIBXq46FusjEkGeGFPYDmxjQFhBO5GSzyPPltBS6F2I1bTR++/hvs600PHfDqzasMC3i5rnp5ZuiFoJR748yze4EbLKZTq9sIfpn9plnrxGid4+922wDbcYCEGsbJ1r6W2pCaSI+Nks+R4wDBGz6Z0sBS5GB7b3y3m7oC0NN96tY3DBAs9ZRSoXgDgjvRNl+kjgcq/QE75JbJC+G7Zfd3sf4WJbbHDcmhxqJgbPcMVKvS7tfY++6fbft3bCJw6KuUGog6XWNPGUMsfgQz6EtHlb5iZjCLanRrJ96oAOgKaWQikObX1UADwOmoe4nuJ+q8kVgPiKLXv3w1SzlVZRzmU8wC7dq03QAymqADB5uAqD9jWzGC865YFXdjxzhzQRI1SDxgiZjD2BjL2tWS/kUl5q/mno92n43udIfubV+EAz4Uy1hCVfB8esfXxVUZm2SqT6hH/uv1d+nv4XvK+Mdi8eJZSXlZmZIdogO8KzK8FFCmPHKrUAbvt+gvoN8xgL1bmKQTYrns+Ftu8y2viZFCAQQpEipcuScyMJaJs2GKGoxIUrmxG2v3mbO4dh6k/4O4wPCGBiyIjRvAyUFysQPMJZnb3F2Fcso39kUi9iNNXldVj8R2HvQY97NiVWAjKgwkHT0+6OjwZy5SiXzmPWCOR/ln6qxvM/ESROz7oH5H1Zb3hMLXSy9XDZe0o/DQG3a+9utfusefPbB6HPCul+WG5tSHWKpCZMExP0bG29+d8NL9voogpY5KLmxZ1gVwMNyE3yHmj73sIzFMAcS18Vn9+2xr88w7Sh0ajdNjNAp5YIhwMjKyRYyMkzx0PSW4QEAjZw8CUbSbSJLIYVUbRRq06RI1FIbfMgFsd0yU1PvBLwnTK7WoiS4V5cyjxGgpUy73J84A030lpMeLQjLd1sI/66J3lLBdCHHRz0uEJQMTlE58SMaliJCv3D6jc09aevGi7eXbw/RrPRWLAbEGLCGYkUST93oVG/hCMeUOZwyX1ucN+EpXXMGgXvfvLdyQAApLiIZeyC1SXAlCucDVq8ahXqKkmQpKkXgeawTrD5s3rqdomxgfo99NnfMznpoqjmfEz3uMt6nTEl6eU+LSEzLDtY8sVyhIgL+313/z934fjx4m7GRKrWxmjSAeAwpx8G1x919nH8/3gnrZUjG2ChCmZNyJYkb5z5FWFbGOifP4z4S9G3xvqTAvSnX0ZF8I53aMmK5afiZyHHMjFZwDwKA04gO8JPTw9ufvl0RLhIPoAVAbiBhWcVEnw5oT4zgiFRTWCW16VWbNwc9Ocj7FHNgmTtDFwhKze2v3V7zWSqSWqcE6yRrZdGAWO0R+k8HxlIcTNJJNfSpCAXCp4NmbAy04eJtLq6JeJcxKLIQaSGca00KP6+ZW0PcvNvNbqcbdsq61yXbXOLjaITfxXoWVjfq/lg4dr1js4Mzd+29q9t8yc3dPz//pxv40MCqvz301kOVf4sQ1a4aYrQYI4J4w8q8CHACNmMpwqEPvIwCyP3IBKLwH0HdsdpP4frL5XbQ9ZTKEi6Gv7P+HQN9UjRmKc6imGzB7RsGzfIcLEXaAhS6sKz+yu0XTxw2ckCVZSs1NlY6ufRpM92RVlvEcoprkbWP7JHaNb1UJpiUhciRDbquTijjhPdl35v3da98+Epxm91kN/bjsW6J+ZdwHYFOrYzMMUtt5VNAempqUsqm+fG/P44KFB8j4Gbw1X0xwYXFkqzUQ6l3UjbBSQIlQYwe/bA1DvO+cQtMYrIXcs2RLACiu3mm0H/rSHlxGWHatYBwR8mweFHE5y1phFaMR8wEaQkTBA8LFUgbcxWPEJrPIjSPa2psrUDpLKbYaUlfe+jqh/p3FmIpPb9EAXzrE5vgCcsB7hiqb1J2vQhYWITkLewPHbMT2+Rx4fDFeN077l53+dOXR+NS1u65tju8z+FeeQiVEYlPof1Ak2fhisA8jatJuzfCVF8sKg++XWvOR/kGPJe5WVYBvHLUlf4LpDYrvf7KKDvNRM79uAYl9Kv/fJWVbZMLOeRYJI8cciDVkrFiXkkGYKMB0pZypiHrMocCIPybFNC0CBBz2qUPVjFOFeZNaM05fsrz9IE2RqWg3U4WUO7v2e+erIwe3jesjj490amVkS+/aY93CPH0O0/7E2NK+OScbLRgxm8q7IWyafE7feqHwc/yzet2iI9bSHLkOZiFJZUsFLZ8/qDVpqb/asUB8O/73rzP5UI4Ciyfu94wYnVe6AMrvkKACZoodhFYuqYECGMHBLCd/m3M32raymbJ/XJOrCmgQEqbLAZHaV/IFkpBRAlaDAUH16LUijJw+bPtplZ+j1KHJUD7uwGCxQLXgp267+R6L9/bB1XH4pHET61dBRbzrdVf2ipWVCk1ZPIVuv2wPRKfouOwwpTeGLMk97IUEQl+1adOxq0oaLIeSOxULDC7o2D1NS4RTt/NYv7Uijj3DTdvfcihLWTyUdlbu2KnRcZWmUw/C6R459Tj2nulvd1n33xWI5dSFrMcTpW2KVZ1q1DewasfnB1oynUQq6WUNkDMSEcFr7rOrozEqKMh+YI8Ch9cTGjFimWFkAhqnU0hloPw1A9Ck7nm5QCyoXFy1Bt5KkKdZ4uyAsJ8+npOaKHPXf+eRcd7WYKGfoNSXOpZWBaS0F0TnoJj7Y2Nx+sfvu4G3D+gYYHHCZ3I/ZCeXFNja7OpRZkdcsJIEGuYMUT0vbBZCv8AykEqgJC2dF+kPRPq2HWOdTPNOFNVu7TFjoj760ZfV7Vx8LdzHznX8xAAeAqs8SOAUjLKchU8EczMfSsg1soKixU0gz6+jPVBU9XLGuELJa8Mh0Ss32Uzpj9yslhg5cWSFGL5bsu7lz94OfnZSsXW566pme+SGaHlVSywF4UAi5hFflUGPFPToKdqEsWCTssqh0XKS8honZPpZ90Dq1xOTR8yqYpchGVjQPQ1mqumTPybgHkJsVoRlu7aMSm9gk4dwOo1xh77mX9jg+UEhiJgBUyetOFJ2bwPmr9BAh35YpEACdgMg5x0kJ4EYAECtdDCLUGtWV91u2WTI9airI9ZczPkFBbkWbSD9wkDw3geCppwDbA5QyMdE1jhhhdrL3EFt4y5xfybWAgahbyXBJpJMS+tTNA+NtqeF/WsCl6Uk1AYIJZis+Qep9x7ShVHQyyAUG+IUpQwbBcgwBruDRSpGD8HLhOLx8X7s7c4x1u8fKzU+EdL9au4MlDUcoqMxXgorDo2gqI1qTdC1lMYdM0p9+i1jzbvE7u3nFJzXA6Sam1hzAdjksHZkkqPGyvkT5EARpQsyP2KQD+gOEjQfT0VzPV8L8MdEo61BP/nFBalD7DepThEULQlWBXktGnNHmvWvFduGYbYNUeve3SpNsTmC9XOGXddqb0MYq57DdoGG3lHolNbRoq0QXzWMJJaAgYfKTERZanIRdhL2lZ4Yk7xYBT5PaW0e0wg5lhyEGT3v3W/N63qOIdUkbIYiQ+xHWGV3lAx476x2BJfdTdSLCts83LdlotSpjfLN6/7V8bNSluMgXZsO3RbH+wnVo8iM3UYUGwFRIvbBM4SYRy1ihLy8xPvPOEFNQqV1S/cW6cUVn2+ra3C2puyUMG7YWX76LT4GL2/hiizRebl8B3FamkFjuv4qtR6g3wt14J4+TOX+w0j5iIN2xBzX3INVqNYULBOpaeduLX69OhT4wKc9J9JpVwrzAfcmGWpCaraNmU9s2lC0uXnkCFvrMB3eZ+cwqLcEwslCiD1YFK09freRSnUz7z3TNNlRvc5pvI1yZxP1Q8TeoNLnrik8nw5vIVW9TLI4Z0auOlA1+2jbq4j0enp4K++5Wp38Et2Zgbl04FVIRQNFZBJQyrfyfednP1cywcYFmsLEaMq10I2lWWRg5AaPVaoD6VIB+M2UpAMbZ8paNFC5/qSCc4lJqZISdLkPpSBJ7uDYGUJFi0yWYfjJoWywmDWHOiCXbo/c8FpVsA7nP3Q2e7mV+zS9dYYE7Bs1SOJKRLNwG173lZVaZU5psnGwkBoUA8VvYxTrI5OTv0UyZL76KuP/M9Fp2T6defld66Kj5AaOmHZBa4l/igM5NVyxXIhMd+wiISuy/B9OAQU1ZohY4mAdk3PzjtbfB9loNestV7C4ochrANX3/n7ujs/vLNKzujA8CI5WnSIKyPDSEMn+yvneqs9jE1KTv11179GD5QWLX9YOsRCaj5IkO5Rax3lhg8f7vr27etmnnlm10y06OAz0W2Wbu73fWtT9tZbdD3P3mcpImj2mpKceAQWd24Of7goxL0iEBeONumnTG3UZ8DV0agiEp5YYnoqQo8TEGbVXHdV7JkoOzETZu4mRMol48QpOma+5f7EOmDaprlU+GXRM8acNvh9kck67F8plFWPC0ii7RljzVGT22+chOVEi6DJUUS0myJ2OpfCftMCBD2zMQhYQ4yBuO0OuOWAqtIHx951bN19C/isVdBPXJaxrCyCemVtE+z57HvPFq4t+jXMRuMzpG9a7lQsqxZvirhrxYWk1xb3o89ijKYiL7xbd4Vq60C4RokhEJ4NvlPfh3vnKCKp9R6+q3YjaRdfDFiXUDI07vjwjprNX2KBdP9JELm+vzDGpuJ9aFfunH/wrQf99RyAihBy3MjYoKDGMOyVYdE5r+9n0etb+wa/FxZoC8TWHLd+MQP09ECnd9N88M0HXmCEWvxj/3zMB7GGJxM2YSvKn+wW2O/IxHn3i3f9pOO+BGsWlaMHXEOQKtdLEKs+8cSyEFhMFIpqJBiVzwmtO0idusK/l32OlebK4sG0S12NlLUFpWvhuRY2+5N74hIatuewSqaPBgKAcQtZDa1gUW2yLgNOTQir3DEIA/l49snvnWxyvciJU2cIEDsU41vJ8ddbwalYWayAwmZwMGjXHLDIxwQ8668v5SlndbVFZaAJXxAbGYGl2mLhM5yeKa4tEsMdr99hshwzBpItFbNAYpUJ47uYr1jjLAVHNiq4NEilFey10l4+yFIjvC+BzEVjLKdo2p3jquVeuE0WmGOBrGBuabsV6BljRu7S1qU9DioobCj3Tx3ipCgj/Y5cyuF9kb7CrVEEHcelC52mWJevHX1t1CLM/XAxsu61giXxaLoQqmRWFmURMd852HSfPa8EyLREp3bTXPbkZe7w4YeXErIpt8Lhaxzu/Zg6qwJCpiKTaQratBmaG8NFbVUvzYWuGhmaxnUbGqnievGPLnY7Lr9jlfANM2Wkz2KuMdwLRWZOLZgkXXXg5gOTVUItU3eOwA3vAYdDbgnwWHXTn9zwk6pTtpjUdT2benhSZDORk5DlHtKCTGKEhHr8yOHVLJkpk3m9aygFYQgO+XkagbhMiEOopz8lNiXqAugyQ1XWiiiTMs9ipvaUW9aKQ5ETvrWhCn9RPX0mJFysfeYe649sJiuI2FK6xO0UygzeYcBGA9xai6zlJn0zqUI5zyk+FRNn/c1ybehnx/pR5jooG/sXgz40YKnRh8sy5JczGH3ps6gi5G4huH7oLkOzDsJgzxX2dIt8uYg7Yvsjmk56lrt/d1rLCIu93x39kn7EcAEL9bD/t6G9Dnl6SE2UORNxo14b+RNzoye4EAgJfbpgk2FTqGKBzdwkCDhlsyZ11MrukDZgRahHqNGWbZfetqpGiJUpQyodyogV4KjrTsQwctzIikIo92Tzmme2eZKshvrUTvuKaN0tcD3ViHNjXaBit3y9x613nLcAMd/gYxCLFdfmKpyb9NrEPfT2Q1UBiYwjc2O+2efz88bietHpr5yAQ2WxEo8xRbGRTQoQb0BafAqS2t115q6l+CXIcDlmvWOiGTxyyuVkXaaODv0Txm4UgT4Y0neIe/TZRz2Fdip+gLYy73RxxBQJliYDK+KfECbVIoI62rf90tt7NuSyGy6KvCivuNFiwcSiDIVKVyy1NkVbn4KlkHC6j1mKmMPEZlnKhlhGG42104ByAaXqw68+rBmPMs+Y3DbZK1kS05abOKDf/6NJH2VbNK97qT2j8YJLLqjEsk1vdFrLSOqUDLZeamvvdw0j6mWgUgszRKNBnjHlKBawpYNPAfEomiLdvP+UjSGlvZfR7MO29+vZz12070VVwVGpMbhi+ytqOFhyLDKNEihxapcidtbzUoHCYunQbLuyUYRBjGJtQunRp+KYVUSo61MnRw3ioPou19cce8aR4mGyUVhjQD/Q75aVTHM4lFlTjboSIW4i1sE6+UtgZ07wZqPgeQ8d8JDb4KoNsk+5oVvCml9hAHkRayabFS4QIagra2nKQVHAs1wj1h4r8D3nXXJBrEZIyx+zFIXBnjAEWyU+vq8Y3HewZy3OXVvNQk5CRRm0AlgLUJT3fc8b9/hTow6mkqBDK2U1BRSRfVbep6H2cg9L+9eBrwImkaSAIaTYOGJBU3LaDfkorEBQaxO2gtnWXnjtquJdZ216ltty/i1rrpM4GAvEQnAKFqGWw+GARaURRSQs/EefaX4V6tykAoVFr5eAVOEF4GQZ8sfs+8N9K8XUJAANTpEwCBKFVwLVchURcMQdR1TaZPnaZd5Y60D64cwHzzStZGyAlqBCWSpCvRsSn6MvrM9LYCd9SJ9Oq4J+ug8spSh6fRBgmiJ0CwMei4KYU0UlmwFpE0G9FnZYdgcfb6bZkqVNAhSZZigivPNmS2xWKJesYHz+/dLEl9z3AalCrBrvffle5d/TanwtlJmHzUSnVUaYnIO3GRwVVDGmR35PoaMymx7PCAPIyiJWrRZfqc5QEITR1tKOsF1UGLY2K36fM/nFZLzxYhtX7v/4O49X5cmfcv8pPlBYQ3zlh65xaPTemhytaDHSP2TTNJLZowUYz9RxGfAaQNZFoGvsGbyrLOJQKGsFBeHNZqZdI1jgYkUKQ0WxlEDpEndnyRigdIVEe7CzWoXhLHKynKj9aQkJ7AxdeIwTp0usQFja9Ljx75M3OLluAf/7Z+2ieTFoEj9OuUWVbFNumjD4W8gTtcJbZh2wdiANtA4glaDJSDDxsFeHeQXQkkEC3IW5SLWbmInU+pPPU8hSgqQFHCBjPETWPXSWDvOkWeC+rH/mZdEYrbnwmlUEi1bV37KQw2cKsTU+rdFpY0ZyYAZpuRlK1VMQs36jAXfUC6HORlGsA7BS//DlmtHoUxZeaC6mNs/MM85cxScSc0/wuwfefiDadj7/7tfvVn4O4xBS0DEMLEbL9yvBXT++7sd1uZBCt4NFc04cyhXPXtHehtUPMQmX6MfUIpZ4mcFPDjbHIrvNmXOPTQThbQFFQ2JrrCDFmGKhWSVz0ycZ41v3vNXMcmoWvBs0eDzt6b1A7yr6/rDOD7FS1ANqdrtCdxQ/k1Gy+dWbV+Z9FQdHQAZm1bgJ56oVcyKxKYx9yl0Vjnmlqu3jv6uQrvE8XIzUVkrBkkEaFDHMAW06ZLVDfNq9BTIWiclIgT4NK6vnKkQQXEJIKHNDu5te/fDVbGWmMBbkpb/6rL7Uml9v0fWq6n/Ju9DHjFHMUpVCjpudMS9LN98sdFrLSFEAa0roMUk4hevTJCcvzRuQY9YvgxFvjIjeJzSrxSjGw5MYkxMeBYtHRQS4nObP3TKeG18E7ilUw7n07tb7WRwEvMMVP77Cu81S99InRn3qCamjQcwlJEJ31YVWNZ9BxdwisIHEsm1yTrO0Gb6UHJ4DAjlRLCxoBVlqlbCBEQAacwfRPlg/Q/CZlCKC5QWyszInO9aPX0+ZIsqyHIYnPEmf5gu3DnEMbHzSDzHrQFnE7mHR8wv4vZzmpV5RCNagzNUY1wjAIoeScd4W50XbxxzCfaitdz5AesvfVHg3kBnEOll1dEKIyzjkuQCk1BfR6x+2+mE+3mrAxgOS1mqs0jkyI3SN5ShEz014zgeMyqFBXN28ExWumwH6PmQ45ndPHPyE/4K+AHJATSsRvgufrwfEnqX6buv5tnav93+9Q4JXO7VlpGzpan2SEV6RsAovCHkDmEDNqEqZ+rymuOZ5VoEzsPpCq7un3q0+cYWLQvONCN7/4v1opH4R2BAGbTPIdXunW7Lft1hiC3fPuHui9+H9YsWmfjrsp4Vtg+9ArifaPRw3jZTlC4FIxowViEm9oL+/9vdKaiwMnshVzS7KBhJD/7X6u0ufvLQqJTms7IyiiHDP4b6ASv+GF6tjUGLg/kWBn+dteZ7JkpoqJkYfsaFJBo8EJRO4G7OUMA/JNGItMe45qdJs1PPONm8hxbwwq1qWnJvH3Ow5PHJTsy0wb+DMCTN6vE2xIFeAUgF/3+vvPlbKms9zzjxnVsyJvDOZWNa6pa/CNS5jivsoLNyYM9esUglFmUH6d1gdUURoO/OMuk7WvJhtptmy5anuD94XZbPIukEJEItvKfXeZeTirivu6telRfO/yRQl0so+kndhDtW7lywzX9qiP+KjEa4j0WmVkRiJGLAGLLyOySETSEOnrsrP06JkuZV6i7UmlYceKiI1pzM32Z882OxyysPrnHrcJChoYt4VunUh1Bn+znD/GfGVh/fk9JVa2PeMvcd99d1XWWNT0043gz/1nPXQWRXXFFlRVp0HfMuYdFEEoFgPs6AkcJDPW3UmJP4jNNFzfVEdG62IYE2QlMqwdkqZKqTNSllEkMNSG7oGDl6tuvCiBUmhFDO+rI8wfdvzMkx635/82MxRcnLbj3+d8RRXDJ/TLirvgnjsdzVVsTVoB/OkXojFwZPrBc/J4fqADRhrzaGr2worShKuUyFBjJGpCWJKQFhZt6gqds4YaGUrdNvkuLVlsw1JwaQ98t1SFGNyI+wPrB5FWL/n+v57bkXqQX0H1ViXi+LabnzpxuS4LVMwtvVkpIncSu1FyLKxH49tOs9ILjqtm4ZFcuK6drnvbZbeptCcnBPkI8FlLErcHWR7TCswcck2aNQCc8zdx/igUfgskooIdVm2ucSnF/JuVBLle0i3jnAREBAcy5UvyvWn9g+8BEkL0RQzfRikxSKDS0IH1VoVdEnXxjpw7N3H+uupNRJWRtUuLNJJrUqjljBHAAjTbwzahE+Mj9CVh8Gw0zOyXlsNaE/oGrBiZywwBvi6NcKsI07y2oRdRuBKjEVIMc9GyxebPApO0Sk3l2314q0vdvv32L9qbuDy42RrVd/mbzluKt6ZtWPNE5lHVkCjRYeeypQS1OM2zYHO9AvbiuwI308CZa0g5MMWOcy7Z6NZbJEDpbaM8Z4pC548C0Uy13IusXXhOOAeQ26EAdPIE8sayEFuUeMAa8kdyfIrA4n9kWekZPpS8y7lOgqdlmcEDH1uqNv7lr3NiczJWE7SseAvThixIkWaLVVOukWuDq6DuhlhMcuMs7hT7jvFTUukSNFS2rcOhNIm2Rh3wmtHvuZGjhzpDn25PIV8LniOdpsVMbVq1lkQ46fAj4uAilF2l2GkZdP9xV2/cE+/93TWO8X4KRCUT7/7dIVgqhk8Njnot2Y/M6i7WfwFjXApyPiHY94I+2gKI/Ye4b588Uu3ygaruLc+fys6NyzODTbpn9yYPpjA5kyQsbUGhQsnZGTWBQJl3miW3ZD9dVrzV4RyElgswsKs+/G/Pzbn14/m/5EvlJf9XKMgX+57FvEMCTTnlMXtVIalOocvatHgbwSwVujv3Qyu7zJ9Pald0ViEfEe6DYcvengNF1Qz0GJgbQAMFvTQsSA+FBUZ1HAzFr+rFhJ8z2HNpLaNLCDuNeC+AU07qQiRG/wpwsop72oh9lw4QygMGAZXYf2J+bGpkzHhywnTVBFByGrhk3OyIb0V0yXX3vdme3qk5UM+ap2johsoJ/EcfZ55Aq16riIS9i3QbgadDZFb/6hRNKKIhD58id3QMTW5WWqW8hVLubeybPR9ztz0TK/0l1lnzDcYZB/7/DG3ilslWtZd5gzzS36WINorvr4iWVcIPo2frvZTU7nCgiAWDd1uHdMm80bH6VibWpnMwLLgniL3QgVJs0QTEB5LawelFJEpz9GyIBVHl+IZ4j7iiqXfsWwgy/wBs0sXXzsIJUcOpNK3ZdyoVqxPzOWvQXxUxS3mJhe6oCSjMlbza4dldnDPP/y860h0WjcNWHfR9hQuC6lNGouJ3owRClLpE+2bE3ZMkYnhJytUn5TqMcelwGIi60Sqw6bMninMNvNs0eCqmPvguHuPc+e/db7Jc9IMQiqCU8MI8CKXCODkKWMWo6YWH7IFa0OIAdffgcMOdGVB3+LeCN0MkgGD8GQzT7ltmk361QjYSMVtQlVclCj+ze9C87TOfApryVi/32CxDcyMMatvxHWyTs91CsePeBltMsesvuGfNnSnjj3VLX3p0lGODauyqoD5Ov7o8e5HS/6o5nO0GSWZDZX+0Nk5Eh9mFZSLZdhZRGQC6fNmZBGlIApS6Oqj77HyNQMSsxMW9ZQKzJpKgGu3XnLrqrm2y/K71GafdZna76KIaEXLGtuyblSdgJADS+5c8uQlbuUFV05+zsqolEKrHZHKG6JTKyMMwA4L7FBagFtpeRSoKtKG91651iUkIPccJYa4hVigWaydYVuZ3OTLhz5r0bTJBqnnJBQT+FJvBNNrkZVAt5V+XHuRxoiyJDDLIuAq2mRy+F/Eh9xoRhZZNvWA/opxErDhXPDoBT77QhOXWTTqKX/99ARVrcMAXx0LwSl+6M5DvcIMWRnpnpjOcZfxnbTTsKidtoyFcRkSWBmm3KOUs2lhKSzCTS/f5Im0aBOuIB0kHqZdCmKpt/o6rGp3j6vmDqJ9mP/15mDJm6L6O2WIq+gH3BrTOg6pHsLIXOiYHYEVhCpuc+bRnfve6ecB1bb5vcjgrf+8dY3SJJ+1EI5tWQVPFMwrE8RxOXJn9PujK//u36e/Kaex6luxKN8HdOqYkW+//dZdfcvVZixD2UqkReB+EBblmNMRvCwqFkS4qcpJT3zAR69ztCmYEJxs0pZ5NjfOIXyW+Ju1H7psvZp6a5Pk1MQoqt9Sz7Ph89h9xd0rptgwrbVZNTcahcQlLTrXom7vm/eualMYT6P99SkyO0E9ZvzYfVNjQNCfBLBacVmxGicS1yPjYsULxcjtyowfbdpiyS1M8kGJNaj8nKj5E4tJCGMdGqmQTV/CGVIGZdY1vDG3v1obo8C73f/m/dH+w3JRthp2DnT8V06ciMRpnPfIee7iJy5uiqwI5wDWcquKMvfmutA1PGNQm8iq5pw7b8PChSmyOzDuw3Hu2juudXtvs3eHVe3t1JYR0G2Wbp4WPtRi/UC3tRcrasaJgU2tyJyuT9FM5HBT5bOcmnQGAhTl1j1ReqD0tsyzuXEOgChseZaYPyULoqy7p5mKCMBcL8pRTv2Wqr7MtBDgyhFTLFYrbXanf+sFz15todWyry0C74bbxqpFo9PQJXVSTNYILCwnMUDkhpJT1prCpspcNddVBhmUNoMjeMnuIsbE+vwfnv1DZVy8O+vR85M1dSTLLcbnEQP3tBQRyQTRhF+WqV7He8A1YbURy4HcoywXkn6ORU6Xk/UnhGfSL9sts535GSpwWzh23WOjc4V5FFqv+F7kXshBGDOh40QssCaovWQpIqAeOaVZc4W4LsavYsWofTfFtRa695j7em7luPC5F4o8hxDdB9q9q0tf4G4scjtOa3R6y8jw4cNd37593c/u+plZi4ONeOxHY6si0vEZX/NcunR4THMPTx9lJr2uTqo1ZzYYi/MCcDry6bZTUPa0ldLWcyLU5VRN2w9a9SB3+ai81El59i173OLueO0ON+ipQU07ackJFF4HTXe/eo9aUrii+9SbxYIbLZatFT6jyHKhcciqh9T0sYwhsE7jqWyTeis1k/LMfGfDt6yBeu7HiMIsN+e1o69N3isG6QO/Vgr4IwgefeDNB7J5gQgMhyE5DGjXa123FRRZooQ4r6xlRFJ8U5l+GlZphpy+ZJOzrLa41ujj0BUHd8qpG5/q/41S+eFXH3p38VufvmUSnOl75rRJZ7fkkJWVXVfhsyAoDBUZLSvryVKaoUCehdl1OqPGAkyuKL9WO2R9glT16GagZRkpATbZy56+LOp3DfkQ4NSIcUxYkIA0oO/Fwt1thWrTYgpsfJbmDKCdt8BkLaoWmkJMW88pXsd7s7hIg7xshcu8v7KsCwZz8AGrHmCetniPmA86yecxhfGQsUCo+uDhLrWkcEVoJJ12/tnnzxL6MJGWsTxd+VztqYYif6kyAan5UK/AFr6a5957zoxpohAjVkeUdOJC4OApshoOHT00yr+RgnBOgBwiq+2X3b5i+StqE+0RRSSMH5D5pe+R059yjzLF71DUaK83zd97ohlYqeGtMy/8tSaYNGdO0pcw6Fp8Ola1V9oNH03Pi3r6L4JJIS8jvTmliMg9iesrir/gOt4F15E1xsvOt2yVNabMurKeRexcKmjYKoRYhHO3ONf3a2x+hrEpHDJZO95CbcyN7a/b3h1393HJ9WkFQv9XVe299NJL3eKLL+5mm202t/baa7snnngief0NN9zgevfu7a9feeWVvTXi+wAGdfTno90//tnO2GgVBQNSFTOs44BmGau5IIvHCkgDGKTw3ROhnQuLGEgmKBTnsQ1bTyxLgeBzKTImgvxidTDwP8aA+R+zLAFiuMM81XOkXkaIg1ZrT0mUsvAxhsVYBkXqZ1EyJdCVwLVplXYce77VbvkbfVTkhrOw7bLbmu+BxQ/3BeM4PcnSaAspm9amxWYEc+VnX3/mT9I51i0+d+x6tW6AQhdSWzuLba4iztzgWmGs1JsYBczCMgYpYZ7aXFLgHre/crtn7UWhYT6Q+h97VyxGWKB0ID3fsVCEsR1hhkk9mWsxN9TLE1+OphzXA08stsB2vmZKUT0m3oVimdY7vfrRq97KWs+6skAxwRC8P3MHi0U4n8OaWPv/cCphHn87eYOTvXJRdMALFQVJSIj1cYpKgPbhGi0ixpteKD0af/nLX9wxxxzjTj/9dPfMM8+4H/7wh27rrbd277//vnn9o48+6vbcc0930EEHuWeffdbtuOOO/uuFF15wHQntJ4P4zDq9dZ+jezQ1TyYCiob+rMR1YDlh4vPdSjXjnpwKcoUBz5ATiSX8OOlbfkSrWFgoYHUcilXszdOiRwRuKuMHevgwywCKc1xHRRsIJyk2UIRpjKTHyqAQJTBcnGEEOShKy9UCJKp0Fgg0r1xseV7N8612S5aHLmAm/mEtyEg1tfD3V+MZOz4l/eGzfPritE7jLIJOj8S9aLFuHriqnQY976zz1hRLLLQ0TLEoSgmIFKRaqrY6ytpAKaCAmQb1lFLCPDfN02pXv+H9fDvY2HAVM2cYvxgsywY/c0KWLL1cmvOizDUrDVuUzGYp9pW6VlMOMgSSFyE1F5gDel2VKdwYIpwHMs/2+ds+NXKd9YYiKVaMobsMdSstuFLFfUebz3747Ep6e+qAJwqPxPnwPWdex0CbsRJ9HzJsSseMYAnp06ePu+SSS/zPkydPdj179nQ/+9nP3Ikn1tKr77777u7LL790t98+VTtfZ5113KqrruqGDBnSITEjsbgJWVDidw3Z6lJMebo0eWwgG4mOJ8aAqospplCElfYjWoyLReyQsShtq1aCxCGkIrsR4usvsn4lNgd2v0b6QcZJE8Tp94kRgCEECGDU9V1yfLos/kPXODTKhslpRkqup7IaYmyKKZZFy6ePYgJtOubuesA4QuPfUDE4N4MbsNEA9+sHf+2mFXDbhAXFGoHEThEMGBIQ0q+nbXSaW3ORNWvouuuJA+DUiytXYMWONIthtgyQEfRpKjYHOROmTluMo6HskyJ5zYJkA/q6VlNkx4SvJjQkN0RGasj6I/hUMxrX656MQWIPU4rgjFPmGla52DyTVH1JL5c4kjEfjCmMuUo9k/jJ/6psmm+++cY9/fTTbosttph6gxlm8D//4x/tm3EIfq+vB1hSYtdPD6TMtVJrhRN/ri9NlyZPaZT1RseDcx4+xy8cLCMWsIxoP2KYAWO1Ocy0iRXWYsJrHovcWgkxc18j/QBoo7xv+D64q2LR9vXUd+HkgJUm5iYiayEWX6CzGmLEUylCKqtuCJHwt71yW2G7o+/TNtmbdXNiIazTlvA5HLLGIcnP5iKW1XTjizdmm9G5R9G1bDT0p1jmtKWJTfaXm/7Su0BTaz53zoQWQR0nBtGZfv705OggS6+oPgupy9bJnDESJmCNRniLUpDMp/BZoTWGbB9ij1A0Un2KghgqInr9ITdljIi/iykiPBuXSlkgt4ssUt8VkEcC2qVrkInLPBZztcqCq0Sfp+v38LXyXCt3KOdIKTr4Dz74wH333Xeue/fuVb/n5zFjxpifee+998zr+X0MX3/9tf/SmhVAe+OrUSz+g8Wj1SkxA6ONf/uDb01rQK+5etXdBp5bL/UyE3XM+2N8IaOidtH+7ou093mZtsbaN3DTge7nfX7udlluF1/VkTYwaeXeR611lPtu8nfu5JEnT82QcDN4E6vvyynXyfdG+sF6X41PJn1ifubTrz6tup52kdJ9xB1HVE5DZPsQABqaWGOR7fJ+YMdld6y6n5iY9fuXxcsTXjY3x399+i9XL2jXmgutWdVWC4zjMWsf4373xO8q/XPU2kd5MiURWOdseo478b5qayjr6uEDHnaTvp3kA4JPGhkPWqYPaccrH77iLnz8wlrz8VpTn596H/oZ6LG06OJZP4xHbC5b81LPNZkzuE9Swcv6WQK9JuX5xIvBTpwD2rX2wmvXtE+Uxpxg6vlnSwdNV951wdr5yv3DdxLUu56ZPyCcQ7rPQ9mx38r7uc16bVY1doJw/R2/zvFu/jnm90zbfRbuU7gOZYxQJMP3YU79ecc/u3UWXcc/c/yn4901o6/Jflf6rqh/Zpzy3qFsKgLXIN/0Z5gTFILddIlN3VZDt6r5DH9/aP+HKv0S9nMzkXvPUm6ad955xy2yyCI+DmTddaeyXh5//PHugQcecI8//njNZ2aZZRb3pz/9yceNCAYNGuR+9atfuQkTJpjP+eUvf+n/HmLo0KGua9eurhm4ecLN7k/v/qnqd0w4sj7wUYIRH45wg8cPrtQm6Nezn9ty/i0bem54z3177OsWmGUBd8Fb6XLpum3Tol1W+7xJsMd+bqfuO2V99oNvPnBjvmxXSnvP0bvSj0XPiUHe7Yv/fOGufvdq3z9F70sbDnmpOq0wHNfw+ne/ftf1mLWH2beMjzxb4N0ly5zrlp1j2cL7NYLYu5yzzDnu+NeOL51qHPadtHXWGWZ1J7x2gtlnIPU+rKPU2PCMa965xj3wyQNVn9N9mBozwJwK1wefP7bXsVXzLOd9isYkZ229+uWrNfcP+znnWdZ7x0CFYNah1b5es/VKtgdsOu+mbu8ee0efR38e0fMI/65l15AlN0D4eZF1QI9b0Rwqg2atv9x5cOv7t7qHP304eS9Zs6kx6qL6X7+LNfet+8vYhO8fm2Myn6YHJk2a5Pbaa69CN00pZQQ3DcrAjTfe6INQBfvvv7/75JNP3LBhw2o+s9hii/mA16OOOqryO4Jfb7nlFvfcc89lW0aIS8Ey00yeEfzHAx5oL0YnJ6wwcA4t2dLCG4F1zz+O+mOVVk/13qEvDK06Zeu2TYt2Tat7oxmPGDHCbbnlllUVIfVzSI/UJ9vwFF6mTWFfWuOaQvisRu/XCGLP5vdyQqe/MFVvueSW7pWJr7jrH7ze/fm9P1c+M3CTgW6NhddI9l0j75gzNhc8doEvSCexTOH9i55ftn3T+n2uePoK1/+u/pXNV6wTZZ9ltfOjf39U6SvGluKUBBmm2mfdhyBJMgXFMhBeJ9bATRfftHLib6T/dLsA/6agIFayonUb6/OY7JgeyJU5XEdtGLHiaWUsXLO6T1mXi82zmM/2Wifof42ye0Pq89Z8mtb9zP7drVu35iojEsC61lpruYsvvrgSwIrC0b9//2gAK5rRbbdN9XOvt956bpVVVumwANaQDr7Xar1c7wV7dzhHfxjMWBTc+N8CTS6XmujNfN9m911HjkWZ4Ffp61Rp+7LPmdbv0ay/N3p9I7ID1PusWDB52fvlfqbZ130fZMf3Abq/QD0B69Nqbyi6flr2c/b+3VYS119/fduss87adtVVV7W99NJLbYceemjbPPPM0/bee+/5v++7775tJ554YuX6Rx55pG2mmWZqO//889tefvnlttNPP71t5plnbhs9enT2Mz/99FMUJv+9mfjmm2/abrnlFv+9hWmHVj9PP7T6evqg1c/TB61+/u/v59z9u1QAq1g6Jk6c6E477TQfhEqK7p133lkJUn377bd9ho22ghDrMWDAAHfyySe7ZZZZxrtoVlpppTr1rBZaaKGFFlpo4X8JpZURgEuGLwv3319bsXG33XbzXy200EILLbTQQgshWrVpWmihhRZaaKGFDkVLGWmhhRZaaKGFFjoULWWkhRZaaKGFFlroULSUkRZaaKGFFlpooUPRUkZaaKGFFlpooYUORUsZaaGFFlpooYUWOhQtZaSFFlpooYUWWuhQtJSRFlpooYUWWmihQ9FSRlpooYUWWmihhf8+BtbpDanlR8GdZoLiQBTx477f9yJM/81o9fP0Q6uvpw9a/Tx90Orn//5+ln27qCbvf4Uy8vnnn/vvPXv27OimtNBCCy200EILdezjVO+NoQvV8tz3HJMnT3bvvPOOm2uuuVyXLl2aqrGh4IwfPz5d2riFhtDq5+mHVl9PH7T6efqg1c///f2MioEisvDCC1cV0f2vtIzwAosuuug0uz+d35ro0x6tfp5+aPX19EGrn6cPWv38393PKYuIoBXA2kILLbTQQgstdChaykgLLbTQQgsttNCh6NTKyKyzzupOP/10/72FaYdWP08/tPp6+qDVz9MHrX7uPP38XxHA2kILLbTQQgst/O+iU1tGWmihhRZaaKGFjkdLGWmhhRZaaKGFFjoULWWkhRZaaKGFFlroULSUkRZaaKGFFlpooUPRqZWRSy+91C2++OJuttlmc2uvvbZ74oknOrpJ31ucffbZrk+fPp4Fd8EFF3Q77rije+WVV6qu+fe//+2OPPJIN//887s555zT7bLLLm7ChAlV17z99ttu2223dV27dvX3Oe6449x//vOfqmvuv/9+t/rqq/vI7qWXXtpdddVVrrPinHPO8azDRx11VOV3rX5uDv71r3+5ffbZx/fj7LPP7lZeeWX31FNPVf5ObP9pp53mevTo4f++xRZbuNdee63qHh999JHbe++9PVHUPPPM4w466CD3xRdfVF3z/PPPuw033NDLGVguzzvvPNdZ8N1337lTTz3VLbHEEr4Pl1pqKXfGGWdU1Slp9XN9ePDBB93222/vmU2REbfcckvV36dnv95www2ud+/e/hrW0fDhw8u/UFsnxfXXX982yyyztP3hD39oe/HFF9sOOeSQtnnmmadtwoQJHd207yW23nrrtj/+8Y9tL7zwQtuoUaPa+vbt27bYYou1ffHFF5VrDj/88LaePXu23XvvvW1PPfVU2zrrrNO23nrrVf7+n//8p22llVZq22KLLdqeffbZtuHDh7d169at7aSTTqpc88Ybb7R17dq17Zhjjml76aWX2i6++OK2GWecse3OO+9s62x44okn2hZffPG2VVZZpe3nP/955fetfm4cH330UVuvXr3aDjjggLbHH3/c98ddd93V9vrrr1euOeecc9rmnnvutltuuaXtueeea/vxj3/ctsQSS7R99dVXlWt+9KMftf3whz9se+yxx9oeeuihtqWXXrptzz33rPz9008/bevevXvb3nvv7dfOdddd1zb77LO3/f73v2/rDBg4cGDb/PPP33b77be3jRs3ru2GG25om3POOdt+97vfVa5p9XN9YF2fcsopbTfddBOaXdvNN99c9ffp1a+PPPKIlx3nnXeelyUDBgxom3nmmdtGjx5d6n06rTKy1lprtR155JGVn7/77ru2hRdeuO3ss8/u0Hb9t+D999/3C+CBBx7wP3/yySd+AiJsBC+//LK/5h//+Edl8cwwwwxt7733XuWawYMHt/3gBz9o+/rrr/3Pxx9/fNuKK65Y9azdd9/dK0OdCZ9//nnbMsss0zZixIi2jTfeuKKMtPq5OTjhhBPaNthgg+jfJ0+e3LbQQgu1/eY3v6n8jr6fddZZvUAGCF76/cknn6xcc8cdd7R16dKl7V//+pf/edCgQW3zzjtvpd/l2cstt1xbZ8C2227b9tOf/rTqdzvvvLPf3ECrn5sDFygj07Nff/KTn/hx1lh77bXbDjvssFLv0CndNN988417+umnvdlK17/h53/84x8d2rb/Fnz66af++3zzzee/05+UodZ9itluscUWq/Qp3zHhde/evXLN1ltv7Ys0vfjii5Vr9D3kms42LrhhcLOEfdHq5+bg1ltvdWuuuabbbbfdvBtrtdVWc5dffnnl7+PGjXPvvfdeVR9RXwN3ru5nTNvcR8D1yJLHH3+8cs1GG23kZplllqp+xsX58ccfu/91rLfeeu7ee+91r776qv/5ueeecw8//LDbZptt/M+tfp42GDcd+7VZsqRTKiMffPCB92VqYQ34mQFsobiKMjEM66+/vltppZX87+g3JiyTO9anfLf6XP6WuoaN9KuvvnKdAddff7175plnfJxOiFY/NwdvvPGGGzx4sFtmmWXcXXfd5fr16+f+3//7f+5Pf/pTVT+lZATfUWQ0ZpppJq+glxmL/2WceOKJbo899vAK88wzz+yVPmQHcQqg1c/TBu9Nx36NXVO23/8rqva28P07tb/wwgv+hNNCc0EJ75///OduxIgRPhishWmnUHMiPOuss/zPbJLM6SFDhrj999+/o5v3P4O//vWv7tprr3VDhw51K664ohs1apRXRgi6bPVzC66zW0a6devmZpxxxpoMBH5eaKGFOqxd/w3o37+/u/322919993nFl100crv6TfcX5988km0T/lu9bn8LXUN0d5EhP+vAzfM+++/77NcOKXw9cADD7j/+7//8//mxNHq58ZBhsEKK6xQ9bvll1/eZyHpfkrJCL4zVhpkLJGhUGYs/pdBFpdYR3Ad7rvvvu7oo4+uWP1a/TxtsNB07NfYNWX7vVMqI5i511hjDe/L1Cclfl533XU7tG3fVxAjhSJy8803u5EjR/pUPQ36EzOs7lP8igh36VO+jx49umoBYAFgA5SNgWv0PeSazjIum2++ue8jTpDyxQkes7b8u9XPjQMXY5iaTlxDr169/L+Z3whT3Ue4sPCl635GKUSBFLA2kCX45uUaUjCJ89H9vNxyy7l5553X/a9j0qRJPgZBg4MgfQRa/TxtsMR07NemyZK2TpzaS2TxVVdd5aOKDz30UJ/aqzMQWpiKfv36+TSx+++/v+3dd9+tfE2aNKkq5ZR035EjR/qU03XXXdd/hSmnW221lU8PJo10gQUWMFNOjzvuOJ8lcumll3aqlFMLOpsGtPq5OWnTM800k089fe2119quvfZa3x9//vOfq1IjkQnDhg1re/7559t22GEHMzVytdVW8+nBDz/8sM+A0qmRZDCQGrnvvvv61EjkDs/5X0451dh///3bFllkkUpqL2mopJmTzSVo9XN9IOOO1H2+2MovvPBC/++33npruvYrqb2spfPPP9/LktNPP72V2lsWcCsg1OEbIdWXXOsWbDDZrS+4RwRM8iOOOMKngjFhd9ppJ6+waLz55ptt22yzjc9VRygde+yxbd9++23VNffdd1/bqquu6sdlySWXrHpGZ0SojLT6uTm47bbbvNLGoaR3795tl112WdXfSY889dRTvTDmms0337ztlVdeqbrmww8/9MIb7gxSpw888EC/SWjA8UAaMfdgY2aT6Cz47LPP/NxFzs4222x+nsGNoVNFW/1cH1i/lkxGAZze/frXv/61bdlll/WyBMqAv//976Xfpwv/V58hqIUWWmihhRZaaKFxdMqYkRZaaKGFFlpo4fuDljLSQgsttNBCCy10KFrKSAsttNBCCy200KFoKSMttNBCCy200EKHoqWMtNBCCy200EILHYqWMtJCCy200EILLXQoWspICy200EILLbTQoWgpIy200EILLbTQQoeipYy00EILLbTQQgsdipYy0kILLbTQQgstdChaykgLLbTQQgsttNChaCkjLbTQQgsttNCC60j8fz7DhYsqbr/dAAAAAElFTkSuQmCC"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 63
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
